-
v2.24.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 26sreleased this
2026-11-08 13:29:51 +00:00 | 44 commits to main since this releaseNOE v2.24.0
This release corrects Headers/Response, Fetch body consumption, stream tee
lifecycle, cloned body byte ownership and multipart framing/serialization.
It includes66c5703,efa3f82,48659fe,f280741and6ca7ec2.
Runtime dependencies, host capabilities and the Go/v2module path are unchanged.Headers and Response
Headers validates ByteString inputs and HTTP names/values, keeps a private list,
observes mutations during iteration and preserves separate Set-Cookie entries.
Request/Response retain stable readonly Headers references. Native HTTP snapshots
preserve wire bytes and private state even when public getters are shadowed.Response validates status, reason phrases and body usability. Metadata is readonly;
constructed responses have type default, empty url and false redirected.
Response.json, error and redirect use their documented standard contracts.
Error/redirect/fetched headers are immutable, including after clone. Native
HEAD/null-body responses release unused readers and expose null body. The existing
WebSocket upgrade helper retains its private status-101 construction path.Body consumption and cloning
Body helpers consume the current stream once. A reader lock alone does not set
bodyUsed; reads and cancellation do. Locked/disturbed bodies reject helpers and
cloning. Byte chunks and helper results are copied, invalid chunks reject and
producer errors retain their identity. Finite cloned/transferred uploads preserve
Content-Length and redirect replay. Fetch retains entry-time headers and observes
an abort before dispatch after buffering. Unusable server responses enter onError
before sending headers.Both tee cancellations share the underlying cleanup result and ordered reasons.
Source errors discard unread buffered data while preserving reads already
accepted. Start both branch cancellations before awaiting them when stopping both.
Body clones isolate ordinary Uint8Array buffers before delivery, so editing or
transferring one branch cannot corrupt its sibling. SharedArrayBuffer remains
shared intentionally. Public tee keeps its existing chunk identity.Multipart data
Multipart parsing recognizes MIME delimiter lines rather than inline boundary-like
text. A field such asbefore--fixtureafterand binary file contents remain intact.
Preamble/epilogue, delimiter padding, chunk splits, part order and trailing file
line breaks are preserved. Outgoing text values normalize CR/LF to CRLF without
changing original FormData entries or file bytes; incoming text stays as received.Behavior compatibility: callers must use public Headers/body APIs instead of
removed implementation properties. Supply valid header names/values, statuses
and byte chunks; initialize native Response metadata through the transport rather
than ResponseInit.url or property writes. Await both tee cancellations together.
These corrections intentionally change previously permissive or inconsistent
behavior. Types, embedded references, examples and main/Worker consumers agree.Scope and verification
Existing native backends, limits, grants and runtime/Worker cleanup remain shared.
Full BodyInit/BufferSource conversion, arbitrary-value cloneForBranch2, resizable
buffer metadata, BYOB/byte-stream controllers, field-name/filename escaping,
broader MIME parsing and browser header/CORS/cache policy remain outside this
release. Complete Web or Deno conformance is not claimed.Implementation evidence includes affected-package tests, focused race, declaration
checks, native HTTP/Worker transfer, independent bounded reviews for the first
four slices, and Deno/Go MIME interoperability for multipart. Required review
findings were fixed and verified. Prepared MCP SDK and Exa fixtures passed without
real provider calls; unchanged checks are reused. Checkout and standalone module
consumers cover main and Workers.Release verification is scoped to version/build metadata and affected native
contracts/examples. CI builds six Linux/macOS/Windows amd64/arm64 binaries and
SHA256SUMS from an immutable tag without repeating source suites. Publication
verification checks downloaded assets, native behavior and direct published Go
consumers. Other target binaries are not executed natively. Go 1.27.2, pinned
go-quickjs v0.32.0 / go-intl v0.8.0, CGO-disabled builds and disabled JIT remain.Publication includes verified installation at both existing vm201 paths, with old
binaries retained. Other hosts, running services and noebot are excluded. See the
release checkpoints,
Headers/Response,
Body consumption,
tee lifecycle,
clone bytes and
multipart records.Downloads
-
Source code (ZIP)
0 downloads
-
Source code (TAR.GZ)
1 download
-
Source code (ZIP)
-
v2.23.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-08 06:08:24 +00:00 | 52 commits to main since this releaseNOE v2.23.0
This release corrects URL/URLSearchParams normalization and encoding, then Request
URL/method handling. It includes99f7f4band68d9437. Runtime dependencies,
host capabilities and the Go/v2module path are unchanged.URL and URLSearchParams
URL constructors, relative resolution and setters apply USVString conversion and
component-specific UTF-8 percent encoding. Existing escapes and empty segments /
query/fragment markers are preserved. Literal and encoded dot segments, supported
special-scheme slashes and default ports normalize consistently. Opaque paths stay
distinct from hierarchical paths; protected serialization avoids creating an
authority from a path. Argument conversion cannot leave setters using stale state.searchParams retains its identity across href/search assignments. Parameter edits
update the linked query through private serialization. Form decoding replaces
malformed UTF-8 locally, preserves a BOM and distinguishes plus from space.
Iterable/record conversion, pair validation, optional value filters, readonly size,
stable UTF-16 sorting and live iteration follow the documented current Web IDL
slice. parse/canParse preserve conversion errors and report parsing failure.Request URL and method inputs
Public Request string/URL input uses the shared Web URL backend. Missing input,
invalid URLs and embedded credentials reject TypeError. NOE supplies no ambient
document base URL; resolve relative values explicitly. Request.url retains its
fragment; native HTTP serialization omits it on the wire.Methods use ByteString and HTTP token validation. CONNECT/TRACE/TRACK reject.
Only DELETE/GET/HEAD/OPTIONS/POST/PUT normalize to uppercase; extension methods such
as patch retain their case, including at native HTTP dispatch. Empty methods no
longer fall back to GET. url/method are branded readonly getters; copy/clone/fetch
use private metadata even when visible properties shadow getters. Current copy /
clone metadata is preserved. Invalid URL/method does not acquire the upload body.Incoming noe:http requests use a private per-runtime factory over the same Request
implementation, preserving native methods/raw URLs and clone/transfer ownership.
The factory is not published and is removed on runtime close. Both installer orders
work. Legacy Network can install before WebAPIs; Request construction requires the
Web URL backend when called.Behavior compatibility: callers now receive encoded URL components, one live
query object and readonly Request URL/method. Use form encoding only where form
semantics are intended. Provide valid methods and credential-free absolute URLs;
spell extension-method case explicitly when the peer distinguishes it. Code that
relied on stale query references, malformed-query fallback, forced uppercase patch,
empty methods or writable Request URL/method must adapt. Types, embedded references,
examples, libraries and main/Worker consumer checks follow the corrected surface.Scope and verification
The existing URL parser/codecs, body/streams, transport, Allow policy and execution
ownership are retained. Full UTS46/IDNA, IP parsing/canonicalization, Windows file
URL quirks and complete URLPattern/Headers/Body/RequestInit/signal/browser-policy
conformance remain outside these corrections. Current primary-spec differences
from Deno/Node are recorded rather than weakening assertions.Affected packages, focused race, declarations/catalog/lint/vet, actual CLI cases
and checkout/standalone-module main/Worker consumers pass. An unchanged prepared
MCP SDK loopback fixture passes initialize/list and three parallel Unicode echo
calls without external services. Independent bounded reviews verified the fixes,
incoming factory privacy/lifetime and both Network/Servers installer orders.Release verification reuses unchanged implementation evidence. CI builds six
Linux/macOS/Windows amd64/arm64 binaries and SHA256SUMS from an immutable tag without
repeating source suites. Native verification is Linux amd64; other assets receive
checksum/build metadata verification. Go 1.27.2, pinned go-quickjs v0.32.0 /
go-intl v0.8.0, CGO-disabled builds and disabled JIT remain selected.Publication includes verified installation at both existing vm201 paths with old
binaries retained. Other hosts, running services and noebot are excluded. See the
release checkpoints, URL/query record
and Request record.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
1 download
-
Source code (ZIP)
-
v2.22.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-08 04:33:24 +00:00 | 57 commits to main since this releaseNOE v2.22.0
This release corrects existing AbortSignal/AbortController, text-stream,
compression-stream and URLPattern input contracts. It includesedb5e73and
f1ad07a. Dependencies, host capabilities and the Go/v2module path are unchanged.Cancellation and text streams
AbortSignal's public constructor is illegal; controller.signal is a branded
readonly getter backed by private state. Default abort and timeout reasons are
AbortError and TimeoutError DOMExceptions. onabort preserves registration order
and inert object-valued slots. timeout applies Web IDL EnforceRange conversion
through JavaScript's safe-integer bound (2^53-1), using staged deadlines over the
existing Loop queue and execution cleanup. Ordinary clearTimeout cannot cancel
these internal deadlines. Legacy WebAPIs installation without a Loop explicitly
rejects timeout; synchronous abort remains available.TextEncoderStream/TextDecoderStream compose the existing TransformStream and UTF-8
codecs. Endpoints and metadata are branded readonly getters. The encoder preserves
UTF-16 surrogate pairs split across chunks, and the decoder requires BufferSources
and exposes fatal/ignoreBOM metadata. Additional encoding families are unsupported.Compression streams
Both constructors validate required formats synchronously before allocating native
work. Supported formats remain gzip, deflate and deflate-raw; Brotli is unsupported.
Endpoints are private readonly attributes. Writes require fixed non-shared
ArrayBuffers or views, snapshot exact spans, and reject strings/arrays/shared or
variable-length backing with TypeError. Detached backing contributes zero bytes.Web decompression rejects forbidden gzip flags, zlib preset dictionaries, invalid
checksums, truncation, trailing bytes and extra gzip members. Writes wait for codec
progress, so a write containing invalid data rejects rather than succeeding before
a later read/close failure. Bounded native output backpressure, cancellation and
the existing 1 GiB cumulative output limit remain. Consume output concurrently;
incremental output can precede a later validation failure. Node zlib synchronous /
callback helpers retain their string convention; create* helpers use Web chunks.
Compression wrapper cloning rejects DataCloneError.URLPattern inputs
Constructor/test/exec accept URLPatternInit dictionaries, including baseURL, with
USVString conversion and standard component inheritance/defaults. Dictionary inputs
carry their own baseURL; combining them with the separate baseURL argument throws
TypeError. exec returns converted snapshots and real component captures. Constructor
parse failures throw; match parse failures return false/null. Conversion exceptions
propagate. Readonly branded component attributes, hasRegExpGroups and ignoreCase
options use private state. Pattern wrappers cannot be structured-cloned.Empty relative strings, query/hash transitions, omitted passwords and relative
leading double slashes have corrected defaults. Shared URL normalization retains
empty path segments while removing dot segments. The retained compiler and URL
backend do not claim full pattern grammar, generated-pattern canonicalization or
IDNA conformance; dynamic dot-segment cases remain documented limits.Behavior compatibility: use supported BufferSources for compression writes,
encode text first, carry dictionary baseURL inside the dictionary, and observe
readonly attributes and standard errors/reasons. Do not rely on discarded trailing
compressed data, additional gzip members, mutable controller/stream/pattern state,
split surrogate replacement, or the former AbortSignal constructor. Public types,
reference pages, examples and main/Worker Go consumers follow these contracts.Verification and distribution
Affected units, focused race, positive/negative types, reference catalog, lint/vet,
actual CLI primary/common/example checks and checkout/standalone-module consumers
pass. Independent bounded abort, URLPattern and compression reviews found issues
that were fixed and checked in one fix-only follow-up per review. Text-stream
internals were reviewed by the parent. No complete Web standards audit is claimed.Release verification reuses unchanged implementation evidence. CI builds six
Linux/macOS/Windows amd64/arm64 binaries and SHA256SUMS from the immutable tag.
Native verification runs on Linux amd64; other assets receive checksum/build
metadata verification. Go 1.27.2, pinned go-quickjs v0.32.0 / go-intl v0.8.0,
CGO-disabled builds and disabled JIT remain selected.Publication includes installing the verified native asset at both existing vm201
executable paths, retaining previous binaries. Other hosts, running services and
noebot are excluded. See checkpoints,
cancellation/text streams, and
compression/URLPattern.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
1 download
-
Source code (ZIP)
-
v2.21.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-08 01:46:34 +00:00 | 62 commits to main since this releaseNOE v2.21.0
This release adds practical User Timing and CustomEvent APIs and corrects the
existing UTF-8 codec and EventTarget listener contracts. It includes implementation
checkpointsa5a52edand2e7228f. Runtime dependencies, host capabilities and the
Go/v2module path are unchanged.Encoding and decoding
- TextEncoder.encodeInto writes complete UTF-8 characters within the destination
view and reports consumed UTF-16 code units and written bytes accurately. - TextDecoder follows UTF-8 error boundaries, retains partial sequences across
streaming calls, handles a BOM split across chunks, and preserves unconsumed
input after fatal streaming errors. All six standard UTF-8 labels are accepted. - Decoder metadata is readonly and branded. Inputs use exact buffer/view spans,
fixed shared backing is supported, and detached decoder inputs are empty.
Resizable/growable backing is rejected under the current Web IDL annotations.
Additional encoding families remain unsupported. - TextDecoderStream, Blob and other existing decoder users share the correction.
User Timing and CustomEvent
performance.mark and measure return actual PerformanceMark/PerformanceMeasure
entries. Entry queries and clear methods operate on each runtime's independent
timeline. Supported overloads, readonly attributes, branded getters, constructor
restrictions and validation follow the documented User Timing slice. Detail is
structured-cloned on entry creation. A standalone PerformanceMark does not enter
the timeline. PerformanceObserver, resource/navigation timing and newer Timeline
id/navigationId fields remain outside the supported surface.CustomEvent extends Event with reference-preserving detail, standard initialization
and legacy initCustomEvent outside dispatch. Event state is readonly and private;
dispatch maintains target/currentTarget/phase, cancellation and propagation flags.
CustomEvent and Performance objects/entries reject structured cloning with
DataCloneError. Existing legacy opaque Event cloning is retained.Event listeners
Listeners are identified by type, callback identity and capture. Duplicate
registration keeps the original options. Capture listeners run before non-capture
listeners at a single target, with separate phase snapshots. Removal during
dispatch takes effect; once listeners are removed before invocation, including
reentrant dispatch. Passive listeners cannot cancel events.The signal option removes listeners through actual abort algorithms before the
signal's abort event. Synthetic abort events do not abort signals or remove bound
listeners. Already-aborted signals prevent registration. Manual/once removal
detaches abort cleanup, while dependent signals retain active algorithms until
cleanup. These semantics also serve messaging, Workers, EventSource, WebSocket
and Performance. No browser DOM tree is introduced.Behavior compatibility: callers relying on duplicate event registrations,
ignored listener options, malformed UTF-8 replacement counts, writable codec /
event state, or empty Performance stubs must adapt. Pass supported BufferSources
and UTF-8 labels, remove listeners with the matching capture flag, and use each
method's standard return value and errors. Types, embedded reference pages,
examples and external Go consumers are aligned.Verification and distribution
Affected stdlib/profile/runtime/CLI tests, focused race, types, docs, lint/vet,
legacy installation without a Loop, actual CLI examples and checkout/standalone
module-artifact Go consumers pass. Main and Workers require no additional grant.
The parent reviewed the decoder; a bounded independent listener review found a
private-abort early-check defect, which was corrected and independently verified.
No complete DOM/Encoding/Performance conformance audit is claimed.Primary specifications control the contracts. Deno 2.9.7 comparison agrees on
core codec/listener corrections but differs on capture ordering and synthetic
abort cleanup; those differences do not weaken NOE's primary assertions.Release verification reuses unchanged implementation evidence. CI builds six
Linux/macOS/Windows amd64/arm64 assets and SHA256SUMS from the immutable tag without
repeating source suites. Native runtime verification is Linux amd64; other targets
receive build/checksum/metadata verification. Go 1.27.2, go-quickjs v0.32.0,
go-intl v0.8.0, CGO-disabled builds and disabled JIT remain selected.The release includes verified installation at both existing vm201 executable
paths with previous binaries retained. Other hosts, running-service restarts and
noebot changes are excluded. See the release checkpoints,
Web API basics,
decoder/listener contract, and
example.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
0 downloads
- TextEncoder.encodeInto writes complete UTF-8 characters within the destination
-
v2.20.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-07 15:04:44 +00:00 | 67 commits to main since this releaseNOE v2.20.0
This release corrects the contracts of existing Web Crypto operations, records
the remaining standard API gaps, and validates practical JWT/JWS use with an
unmodified SDK. Implementation checkpoints are6c8a23dand the deriveKey
error-order follow-up2e8a197. Runtime dependencies and the Go/v2module
path are unchanged.Corrected Web Crypto contracts
Supported operations remain SHA-1/256/384/512 digest, raw HMAC import/export /
sign/verify, and raw PBKDF2/HKDF import/deriveBits plus deriveKey to HMAC.- CryptoKey is a branded illegal constructor with readonly attributes and
cached visible metadata. Private snapshots govern material, algorithms,
usages and extractability. Mutating or shadowing metadata grants no authority. - Sign and verify require their own key usages independently. A verify-only
key cannot sign; verification does not additionally require sign permission.
Non-extractable HMAC keys cannot be exported through public-property changes. - Subtle methods copy BufferSource inputs with exact view offsets before
yielding. Ordinary arrays/strings, detached buffers and shared-backed inputs
reject with the specified errors. Registered Web names normalize ASCII case;
Node hash aliases do not extend the Web registry. - Import, derivation and export enforce key formats, usages, algorithm data,
length constraints and standard error names. Unsupported export operations
are checked before extractability. deriveKey checks base-key access before
executing target key-length validation, and needs no deriveBits permission. - HMAC's default derived length is the selected hash block size. The current
draft's zero-bit PBKDF2 result is supported after positive-iteration validation. - Native CPU calculations run off the VM owner when a Loop exists. Runtime /
Worker cleanup cancels and joins owned work, dropping undelivered results.
Legacy WebAPIs installation without a Loop may compute a settled promise. - getRandomValues enforces integer-view and 65,536-byte contracts with standard
DOMException names. Random-source selection and randomUUID v4 are preserved.
Behavior compatibility: callers relying on permissive key metadata,
cross-operation usages, non-BufferSource input coercion, Node hash aliases in
subtle, or previous error names must adapt. Import separate keys with the
required usages, request extractability at import when appropriate, and pass
ArrayBuffers or supported views. Node-style crypto helpers retain their own
byte/text conventions; their webcrypto/subtle exports remain identical to the
global objects. No new Profile field or host capability is required.Practical SDK proof and remaining gaps
The pinned, unmodified
jose6.2.15 Web API ESM distribution passes HS256 /
HS384/HS512 JWT/JWS signing and verification with raw and CryptoKey inputs,
modified-signature/expiration/issuer/audience rejection, main/Worker execution,
and two-way Node interoperability. SDK files retain their original fingerprints.
Node/npm prepare dependencies; NOE executes the fixture without patches or
polyfills. No real login or application-provider call is used.This does not claim complete Web Crypto or jose support. generateKey,
encrypt/decrypt, wrapKey/unwrapKey, native JWK/SPKI/PKCS8, public-key and
encryption algorithm families, full Crypto/SubtleCrypto interface shape, and
CryptoKey structured cloning remain unsupported. Cloning rejects DataCloneError;
Workers can import their own raw material. Actual SDK probes record generation,
CryptoKey JWK export, and AES-GCM JWE gaps.See the examples,
Go embedding guide,
API reference, and
contract, gap inventory and evidence.Verification and distribution
Implementation evidence covers affected units, focused race, declarations,
embedded docs, lint/vet, public Go consumers from checkout and source artifacts,
native cancellation, and actual SDK interoperability. A user-requested pi
review with GLM 5.3 / max completed; the parent verified its claims against
primary specifications and fixed the accepted error-precedence issue with a
baseline-failing regression. No independent fix re-review or full API audit
is claimed.Release verification reuses unchanged implementation evidence. CI builds the
six Linux/macOS/Windows amd64/arm64 binaries and SHA256SUMS from the immutable
tag without repeating source suites. Native execution is Linux amd64; other
targets receive build/checksum/metadata verification. Go 1.27.2, go-quickjs
v0.32.0, go-intl v0.8.0, CGO-disabled builds and disabled JIT remain selected.The release includes verified installation at both existing vm201 executable
paths with previous binaries retained. Other hosts, service restarts and
noebot changes are excluded. See the release checkpoints
for publication and installation evidence.Downloads
-
Source code (ZIP)
0 downloads
-
Source code (TAR.GZ)
1 download
- CryptoKey is a branded illegal constructor with readonly attributes and
-
v2.19.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-07 07:46:56 +00:00 | 73 commits to main since this releaseNOE v2.19.0
This release adds
sessionStorageand explicit-filelocalStoragethrough
the Web Storage interface. The implementation isdfa497e. No runtime
dependency or engine change is required.Session and persistent storage
StorageandsessionStorageaccompany the default Web APIs. Each runtime,
including each Worker, starts with its own empty session store. Use the stable
global object;new Storage()is not supported.sessionStorage.setItem("message", "hello"); console.log(sessionStorage.getItem("message"));Persistent storage has no default location. CLI
runandevalaccept
--local-storage pathbefore their script/code operand:noe run --local-storage ./state.json examples/storage/web-storage.js noe eval --local-storage ./state.json 'console.log(localStorage.length)'The containing directory must already exist. The first changing mutation
creates the file. Each synchronous change commits atomically through the
existing filesystem backend before returning. Failed writes preserve previous
data, invalid stored documents raiseInvalidStateError, and read-only
filesystem mutations raiseSecurityError. Storage does not silently fall
back to memory. Keys and values preserve UTF-16, including unpaired surrogates.Both objects provide
length,key,getItem,setItem,removeItem, and
clear, plus named property assignment, reads, deletion, and enumeration.
Missing items return null through methods and undefined through property
reads. DOMString conversion, required arguments, receiver checks, and
method-name collisions follow the documented Storage contract. Instances
cannot be structured-cloned or transferred.Go selection and compatibility
profile := stdlib.Profile{ Environment: stdlib.Environment{Cwd: "/"}, Modules: stdlib.Modules{ FS: &stdlib.FileSystemOptions{Root: dataDirectory}, LocalStorage: &stdlib.LocalStorageOptions{Path: "state.json"}, }, }Modules.LocalStoragerequires the existing FS capability. Root, Cwd, and
ReadOnly apply, and paths/options are snapshotted before Worker creation.
Nil leaves thelocalStorageglobal absent. Selecting storage adds no network
or command authority. Session storage needs no external capability.Go source compatibility:
LocalStorageadds a field toModules.
Consumers using unkeyed struct literals must move to named fields. Existing
keyed selections and the public/v2module path remain supported. No existing
JavaScript API or import is removed.Host model and limits
Main runtimes and Workers selecting the same canonical file observe committed
local data. Operations are serialized within the NOE process. Separate OS
processes and ordinary filesystem edits do not join that coordination; use
noe:sqlitefor cross-process transactional state. A multi-call
get/increment/set sequence is not a transaction.NOE has no Window, Document, browser origin partition, or storage events.
Worker exposure is a NOE extension; sessions remain runtime-local. Storage is
synchronous, unencrypted, and has no added quota. The Proxy facade rejects
Object.definePropertyrequests withconfigurable: falsebefore mutation;
configurable data descriptors are supported.See the example,
Go embedding guide,
API reference, and
implementation contract.Verification and distribution
Implementation checks cover public string/property semantics, file authority,
UTF-16 persistence, Worker sharing/isolation, option snapshots, cleanup,
concurrent updates, CLI executions/example, declarations/docs, and external Go
consumers. A prototype descriptor getter deadlock found during bounded review
was fixed before release. Its regression fails on the earlier source and
passes on the corrected implementation; focused race tests and fix-only
re-review pass.Release preparation reuses unchanged implementation results. CI builds the
six Linux/macOS/Windows amd64/arm64 assets and SHA256SUMS from the immutable tag
without repeating local source suites. Native execution is Linux amd64; other
targets receive build/checksum/metadata verification. Go 1.27.2, go-quickjs
v0.32.0, go-intl v0.8.0, CGO-disabled distribution builds, and disabled JIT
remain selected.This release request includes verification and installation of the published
native asset at both existing vm201 executable paths, with previous binaries
retained. Other hosts, service restarts, and noebot changes are excluded. See
the release checkpoints for publication and
installation evidence.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
2 downloads
-
Source code (ZIP)
-
v2.18.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 21sreleased this
2026-11-07 05:07:17 +00:00 | 77 commits to main since this releaseNOE v2.18.0
This release adds raw TLS streams and UDP datagram sockets to
noe:sockets.
Both reuse the existing native resource ownership and execution/Worker cleanup.
No dependency changes are required. HTTPS/WSS listeners remain available
throughnoe:http, as introduced in v2.17.0.Raw TLS streams
Use
network: "tls"withconnectandlisten. Connections retain the
existingreadable,writable,close, and asynchronous-disposal interface.
Connect and accept return only after their TLS handshake succeeds.import {readFile} from "noe:fs"; import {connect, listen} from "noe:sockets"; const cert = await readFile("server-cert.pem", "utf8"); const key = await readFile("server-key.pem", "utf8"); await using listener = await listen({ network: "tls", host: "127.0.0.1", port: 0, cert, key, }); const accepting = listener.accept(); await using client = await connect({ ...listener.address, ca: cert, }); await using server = await accepting; // Exchange bytes through client/server readable and writable Web Streams.Start accept before awaiting a loopback client so the server can complete its
handshake. The example identity must include IP:127.0.0.1 in its certificate
subject alternative names. See the
complete TLS round-trip example.Clients verify the certificate chain and hostname using system roots by
default. OptionalcaPEM replaces roots for that connection;serverName
selects the verification name. Optional clientcert/keyenables a client
identity. Listeners require a matching PEM pair or Go host configuration.
Invalid or conflicting settings reject before dial/bind without exposing PEM
material. Values contain PEM text, not implicit file paths; explicit file reads
remain under the selectednoe:fscapability and its Root/Cwd/ReadOnly policy.writer.close()sends TLS close_notify and leaves reads available. Reader
cancellation stops local delivery without waiting behind TLS protocol-alert
writes; the connection retains that native work until full close. Writer abort
and full close interrupt transport operations without waiting for a graceful
alert. Listener close cancels pending handshakes and undelivered results;
connections already returned retain independent ownership.Go TLS configuration and compatibility
Keep selecting
Modules.RawSockets: true. New
Modules.RawSocketsTLS *stdlib.SocketTLSOptionsconfigures Client and Server
*tls.Configvalues plus HandshakeTimeout, without granting sockets by itself.
A non-nil direction configuration is authoritative; corresponding inline
JavaScript TLS fields cannot override it. Raw TLS preserves host ALPN choices.
HTTP/Fetch/WebSocket trust and capabilities remain independent.profile.Modules = stdlib.Modules{ RawSockets: true, RawSocketsTLS: &stdlib.SocketTLSOptions{ Client: &tls.Config{RootCAs: roots}, Server: &tls.Config{Certificates: []tls.Certificate{certificate}}, }, }This fragment uses
crypto/tlsand previously loaded roots/certificate material.
Configuration copies are cloned for profiles, runtimes, Workers, and listeners.
Referenced keys, pools, caches, and callbacks retain Go's immutable-in-use
ownership. The handshake timer defaults to ten seconds; positive values
override it, and a negative value disables it. Owner cancellation stays active.Go source compatibility: the additional
Modulesfield requires external
unkeyed struct literals to move to named fields. Existing keyed selections and
the public/v2module path remain supported. See the
raw TLS contract.UDP datagrams
New
bindcreates an owned UDP socket with explicit packet operations. Stream
connect/listen return types remain unchanged.import {bind} from "noe:sockets"; await using receiver = await bind({network: "udp", host: "127.0.0.1", port: 0}); await using sender = await bind({network: "udp", host: "127.0.0.1", port: 0}); const receiving = receiver.receive(); await sender.send(new Uint8Array([0, 128, 255]), receiver.address); const {data, remoteAddress} = await receiving; console.log([...data], remoteAddress);One send/receive handles one packet, including an empty datagram. Send snapshots
Uint8Array bytes before asynchronous work and returns the local OS byte count.
Receive returns fresh bytes and the sender's{network: "udp", host, port}.
Host resolution supports IPv4/IPv6. OS routing/size failures reject. A 65,536-byte
receive buffer accommodates ordinary UDP; read errors and full buffers reject
instead of exposing a possible partial payload. UDP adds no delivery, order,
duplicate suppression, or retry guarantee.Bind/send/receive accept operation-scoped AbortSignal and preserve its exact
reason. Canceling one operation does not disturb another. Bind signal ownership
ends at return; cancellation cannot withdraw a packet already accepted by the
OS and may discard an already received packet.close()returns one shared
Promise, cancels pending operations, and releases native I/O. Async
disposal and runtime/Worker teardown use the same ownership model.UDP uses the existing RawSockets grant, with no new Go option or implicit
FS/HTTP/WebSocket capability. See the
UDP round-trip example
and UDP contract.Verification and distribution
Implementation verification covers trust/hostname/mTLS, host configuration
snapshots, scoped cancellation/deadline reset, queued result ownership,
blocked I/O, Worker/runtime cleanup, UDP packet boundaries/addresses, IPv6,
types, CLI examples, and standalone public Go consumers. Affected race checks,
vet, and bounded reviews pass. Consumers build with CGO disabled for all six
release targets. Release preparation reuses unchanged implementation evidence.Generated
dist/is now ignored by Git, so earlier CI build outputs no longer
mark later binaries' VCS metadata dirty. CI builds six distribution binaries,
creates SHA256SUMS, and publishes the immutable tag without repeating local
source suites. Native execution is Linux amd64; other targets receive
build/checksum verification. Go 1.27.2, go-quickjs v0.32.0, go-intl v0.8.0,
and disabled JIT remain selected.Release requests include verified local installation at both executable paths.
Running-service restarts and noebot changes remain separate. See the
release checkpoints for publication and installation
evidence.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
0 downloads
-
Source code (ZIP)
-
v2.17.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 24sreleased this
2026-11-07 02:07:34 +00:00 | 84 commits to main since this releaseNOE v2.17.0
This release adds HTTPS listeners and WSS upgrades to
noe:http, sharing the
existing HTTP/1.1 server, WebSocket transport, grants, and resource ownership.
No dependency changes are required.HTTPS and WSS
Pass certificate and private-key PEM text to
serve:import {readFile} from "noe:fs"; import {serve, upgradeWebSocket} from "noe:http"; const server = serve({ hostname: "127.0.0.1", port: 8443, cert: await readFile("server-cert.pem", "utf8"), key: await readFile("server-key.pem", "utf8"), }, request => { if (new URL(request.url).pathname === "/ws") { const {socket, response} = upgradeWebSocket(request); socket.onmessage = event => socket.send(event.data); return response; } return Response.json({url: request.url}); }); console.log(server.url); // https://127.0.0.1:8443Both options must be nonempty strings.
certaccepts a concatenated PEM
certificate chain. Supplying only one option, null/non-string values, malformed
PEM, or a mismatched pair throws TypeError synchronously before bind
authorization or opening a listener.
Diagnostics omit the supplied certificate and private-key text.These options contain PEM data, not file paths. File reads remain explicit
noe:fsoperations under the selected Root/Cwd/ReadOnly settings. Inline TLS
does not grant filesystem, Fetch, or WebSocket access.serverequires Serve;
upgradeWebSocketrequires both Serve and WebSockets.Server URLs and incoming HTTPS Request URLs use
https://. Clients connect
to the correspondingwss://URL for WebSockets. TLS listeners use HTTP/1.1;
HTTP/2 and automatic certificate issuance/reload are outside this addition.
Outgoing Fetch and WebSocket trust configurations remain independent.See the runnable HTTPS/WSS example
and full listener contract.Go embedding and compatibility
Go hosts may select HTTPS with
stdlib.ServeOptions.TLS *tls.Configinstead
of exposing private keys to JavaScript. A non-nil configuration must supply
Certificates,GetCertificate, orGetConfigForClient. JavaScript cert/key
options conflict with host TLS and cannot override its policy.profile.Modules.Serve = &stdlib.ServeOptions{ Allow: func(address string) error { return nil }, // Set the host's bind policy. TLS: &tls.Config{Certificates: []tls.Certificate{certificate}}, }This fragment uses
crypto/tlsand a previously loadedtls.Certificate.
Profile/runtime/Worker/listener copies clone the TLS configuration. Referenced
certificate/key objects, pools, and callbacks remain shared and immutable in
use. Callback-selected configurations are cloned and advertise HTTP/1.1
without changing the caller's configuration.Go source compatibility: the new field changes the exported ServeOptions
struct shape. External unkeyed literals must use named fields. Existing keyed
literals, JavaScript HTTP calls without TLS options, capability selection,
and the public/v2module path remain supported.Cleanup and verification
HTTPS uses the same body limits, handler admission, asynchronous idempotent
close, async disposal, five-second graceful allowance, and forced runtime/
Worker teardown as HTTP. Forced cleanup also interrupts stalled TLS
handshakes. Upgraded sockets keep their own lifetime; closing the listener
does not close them.Implementation verification covers HTTPS/HTTP and WSS data/close exchange,
validation before authorization/bind, host policy and runtime snapshots,
callback ALPN, Worker inheritance/termination, stalled-handshake cleanup,
race detection, the real CLI example, types, and public module consumers.
Consumers run with CGO disabled against both the checkout and an isolated
module artifact and build for all six distribution targets. An existing
WebSocket regression test now synchronizes its handshake response so owner
job delivery cannot invalidate its opening-only wait; socket behavior is
unchanged by that test correction.Release preparation reuses unchanged implementation evidence. CI builds the
six CGO-disabled binaries, creates SHA256SUMS, and publishes the selected
immutable tag without repeating local source suites. Native execution is
verified on Linux amd64; other targets receive build/checksum verification.
Go 1.27.2, go-quickjs v0.32.0, go-intl v0.8.0, and disabled JIT remain selected.
See the release checkpoints for preparation and
publication status. Binary installation and running-service restarts are
separate actions.Downloads
-
Source code (ZIP)
0 downloads
-
Source code (TAR.GZ)
1 download
-
Source code (ZIP)
-
v2.16.0
StableAll checks were successfulrelease / build-and-release (push) Successful in 1m23sreleased this
2026-11-06 23:55:17 +00:00 | 89 commits to main since this releaseNOE v2.16.0
This release adds standard EventSource and asynchronous SQLite, consolidates
host APIs undernoe:fs,noe:process, andnoe:http, and corrects HTTP body
limits and WebSocket lifecycle behavior.JavaScript compatibility changes: the old filesystem, process, and HTTP
imports are removed without adapters. Standard-I/O and filesystem entry points,
custom WebSocket headers, server close, and several WebSocket defaults change.
Use the v2.16.0 migration guide when upgrading from
v2.15.0. The public Go packages retain the/v2module path and independent
capability selection.Host APIs
noe:fsis the filesystem module. Direct operations are asynchronous,
explicitSynchelpers remain, open uses options, FileHandle has concise
read/readAt/write/writeAt methods, and watch is an async iterator. The
node:fs,node:fs/promises,fs, andfs/promisesimports are removed.noe:processcombines the selected command functions, stdin/stdout/stderr
byte Web Streams, and namedprocessmetadata/control object. The default
object is the selected module namespace, with metadata under.process.
Globalprocessremains. Thenode:child_process,child_process,
node:process, andprocessimports are removed.noe:httpcontains capability-selectedserve,createWebSocket, and
upgradeWebSocket, without a default or fetch export. Thenode:httpand
httpimports and global serve/upgradeWebSocket helpers are removed.
Standard Fetch, Request/Response, WebSocket, EventSource, and Streams remain
global. Custom handshake headers move from the constructor's third argument
tocreateWebSocket(url, {protocols, headers}).
These entrances share the existing native implementations. Root, Cwd,
ReadOnly, URL/command grants, borrowed resources, execution cancellation,
and main/Worker capability boundaries remain in force.EventSource
new EventSource(url)consumes server-sent events through Fetch authority.
It supports named events, multiline messages, IDs and Last-Event-ID on
reconnection, retry fields, and cancellation byclose(). It is inherited
by Workers when Fetch is selected. No additional network capability is
introduced, and no custom-header constructor extension is added.The selected HTTP client and redirects use the existing Fetch backend.
The subscription can remain active while receiving many small events; the
host buffer limit applies to a partial event rather than lifetime traffic.
See the EventSource contract.Asynchronous SQLite
noe:sqliteprovides Promise-based open/exec/run/get/all/prepare/transaction/
close and asynchronous disposal. SQL runs off the JS owner, and each
connection serializes submissions. Transaction callbacks reserve their queue
through commit or rollback, including awaits and cancellation.import {open} from "noe:sqlite"; await using db = await open(":memory:"); await db.exec("CREATE TABLE notes(text TEXT)"); await db.run("INSERT INTO notes VALUES(?)", ["hello"]); console.log(await db.get("SELECT text FROM notes"));Memory databases need no filesystem grant. File databases share the selected
filesystem, including sidecar authority, Root/Cwd/ReadOnly, and forced
execution cleanup. BLOBs use copied typed arrays; integers outside the safe
number range use bigint. Statements support reuse and async disposal.
WAL is supported on writable profiles; FS.ReadOnly profiles refuse WAL-format
databases because their shared-memory sidecar can require writes. Use
rollback-journal databases there. See the
SQLite contract.SQLite adds
github.com/ncruces/go-sqlite3v0.36.0 and its translated SQLite
support dependencies. The runtime remains CGO-free across the six release
targets; this does not expose a general JavaScript WebAssembly/FFI API.HTTP limits and cleanup
Fetch response limits and Serve request limits now reject actual overflow
instead of successfully returning a truncated prefix. Bodies exactly at the
cap succeed after a bounded EOF probe. Zero selects the 32 MiB default and
negative values disable the host body bound.Serve body overflow rejects with RangeError and
ERR_HTTP_BODY_TOO_LARGE.
Uncaught overflow yields 413 before response headers; onError can override
that response. A response already streaming is aborted on overflow.server.close()returns the same Promise on repeated calls. It stops
handler admission immediately and waits asynchronously for handlers/body I/O,
with the existing five-second graceful allowance and forced fallback.
Symbol.asyncDisposedelegates to close. A shutdown handler can initiate
close and return a response; await completion outside that handler. Forced
runtime/Worker cleanup remains independent, and upgraded sockets have their
own lifetime. See Serve details
and the Fetch correction.WebSocket behavior
- Binary messages default to Blob; set binaryType to
"arraybuffer"for raw
ArrayBuffer delivery. Blob/File sends use the native binary queue while
preserving message order and payload snapshots. - Closing during CONNECTING interrupts dialing/HTTP handshake. Late results
cannot reopen a closed socket. Execution cancellation and Worker termination
interrupt stalled handshakes and blocked writes. - Close arguments are validated before state changes, including repeated
close calls. Invalid codes throw InvalidAccessError; reasons over 123 UTF-8
bytes throw SyntaxError. - Established close flushes accepted sends and waits up to five seconds for
the close-frame exchange. A no-argument close sends an empty frame; use
close(1000) for an explicit status. The event reports the first peer
code/reason, with 1005 for an empty frame or 1006/empty reason when no close
arrived. wasClean requires successful frames in both directions. - Native closing continues while JavaScript is busy, and force cleanup can
interrupt pending I/O without waiting for graceful completion. Error details
remain on the error event, rather than replacing the peer close reason.
See opening lifecycle and
connected close.Verification and distribution
Per-slice verification covers affected unit/race tests, CLI/Worker/fixture-
agent routes, native ownership, grants, independent capability selections,
public consumers from standalone Go module artifacts, type declarations,
and bounded reviews. SQLite and consumer builds cover the six release
targets. Release preparation reuses these results for unchanged source and
checks the release candidate and documentation with focused smoke.The tag-triggered CI builds all six CGO-disabled distribution binaries,
creates SHA256SUMS, and uploads this release without repeating local source
suites. Downloaded assets, build metadata, native smoke, and published-module
consumers are verified after publication. Native execution is Linux amd64;
other targets receive build/checksum verification.Go 1.27.2, official go-quickjs v0.32.0, go-intl v0.8.0, and disabled JIT remain
selected. Installed executables and running applications are separate from
publishing these assets. See the release checkpoints.Downloads
-
Source code (ZIP)
1 download
-
Source code (TAR.GZ)
1 download