• v2.24.0 0ab4e4eb67

    v2.24.0
    All checks were successful
    release / build-and-release (push) Successful in 26s
    Stable

    littleisland released this 2026-11-08 13:29:51 +00:00 | 44 commits to main since this release

    NOE v2.24.0

    This release corrects Headers/Response, Fetch body consumption, stream tee
    lifecycle, cloned body byte ownership and multipart framing/serialization.
    It includes 66c5703, efa3f82, 48659fe, f280741 and 6ca7ec2.
    Runtime dependencies, host capabilities and the Go /v2 module 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 as before--fixtureafter and 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
  • v2.23.0 a2efaa4de9

    v2.23.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-08 06:08:24 +00:00 | 52 commits to main since this release

    NOE v2.23.0

    This release corrects URL/URLSearchParams normalization and encoding, then Request
    URL/method handling. It includes 99f7f4b and 68d9437. Runtime dependencies,
    host capabilities and the Go /v2 module 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
  • v2.22.0 a8e0545706

    v2.22.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-08 04:33:24 +00:00 | 57 commits to main since this release

    NOE v2.22.0

    This release corrects existing AbortSignal/AbortController, text-stream,
    compression-stream and URLPattern input contracts. It includes edb5e73 and
    f1ad07a. Dependencies, host capabilities and the Go /v2 module 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
  • v2.21.0 904f3e770a

    v2.21.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-08 01:46:34 +00:00 | 62 commits to main since this release

    NOE 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
    checkpoints a5a52ed and 2e7228f. Runtime dependencies, host capabilities and the
    Go /v2 module 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
  • v2.20.0 6a2891df95

    v2.20.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-07 15:04:44 +00:00 | 67 commits to main since this release

    NOE 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 are 6c8a23d and the deriveKey
    error-order follow-up 2e8a197. Runtime dependencies and the Go /v2 module
    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 jose 6.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
  • v2.19.0 4e6721d84c

    v2.19.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-07 07:46:56 +00:00 | 73 commits to main since this release

    NOE v2.19.0

    This release adds sessionStorage and explicit-file localStorage through
    the Web Storage interface. The implementation is dfa497e. No runtime
    dependency or engine change is required.

    Session and persistent storage

    Storage and sessionStorage accompany 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 run and eval accept
    --local-storage path before 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 raise InvalidStateError, and read-only
    filesystem mutations raise SecurityError. 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.LocalStorage requires the existing FS capability. Root, Cwd, and
    ReadOnly apply, and paths/options are snapshotted before Worker creation.
    Nil leaves the localStorage global absent. Selecting storage adds no network
    or command authority. Session storage needs no external capability.

    Go source compatibility: LocalStorage adds a field to Modules.
    Consumers using unkeyed struct literals must move to named fields. Existing
    keyed selections and the public /v2 module 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:sqlite for 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.defineProperty requests with configurable: false before 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
  • v2.18.0 51f08bc3da

    v2.18.0
    All checks were successful
    release / build-and-release (push) Successful in 21s
    Stable

    littleisland released this 2026-11-07 05:07:17 +00:00 | 77 commits to main since this release

    NOE 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
    through noe:http, as introduced in v2.17.0.

    Raw TLS streams

    Use network: "tls" with connect and listen. Connections retain the
    existing readable, 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. Optional ca PEM replaces roots for that connection; serverName
    selects the verification name. Optional client cert/key enables 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 selected noe:fs capability 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.SocketTLSOptions configures Client and Server
    *tls.Config values 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/tls and 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 Modules field requires external
    unkeyed struct literals to move to named fields. Existing keyed selections and
    the public /v2 module path remain supported. See the
    raw TLS contract.

    UDP datagrams

    New bind creates 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
  • v2.17.0 438f0bf119

    v2.17.0
    All checks were successful
    release / build-and-release (push) Successful in 24s
    Stable

    littleisland released this 2026-11-07 02:07:34 +00:00 | 84 commits to main since this release

    NOE 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:8443
    

    Both options must be nonempty strings. cert accepts 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:fs operations under the selected Root/Cwd/ReadOnly settings. Inline TLS
    does not grant filesystem, Fetch, or WebSocket access. serve requires Serve;
    upgradeWebSocket requires both Serve and WebSockets.

    Server URLs and incoming HTTPS Request URLs use https://. Clients connect
    to the corresponding wss:// 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.Config instead
    of exposing private keys to JavaScript. A non-nil configuration must supply
    Certificates, GetCertificate, or GetConfigForClient. 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/tls and a previously loaded tls.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 /v2 module 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
  • v2.16.0 797b9fbfa9

    v2.16.0
    All checks were successful
    release / build-and-release (push) Successful in 1m23s
    Stable

    littleisland released this 2026-11-06 23:55:17 +00:00 | 89 commits to main since this release

    NOE v2.16.0

    This release adds standard EventSource and asynchronous SQLite, consolidates
    host APIs under noe:fs, noe:process, and noe: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 /v2 module path and independent
    capability selection.

    Host APIs

    • noe:fs is the filesystem module. Direct operations are asynchronous,
      explicit Sync helpers 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, and fs/promises imports are removed.
    • noe:process combines the selected command functions, stdin/stdout/stderr
      byte Web Streams, and named process metadata/control object. The default
      object is the selected module namespace, with metadata under .process.
      Global process remains. The node:child_process, child_process,
      node:process, and process imports are removed.
    • noe:http contains capability-selected serve, createWebSocket, and
      upgradeWebSocket, without a default or fetch export. The node:http and
      http imports 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
      to createWebSocket(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 by close(). 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:sqlite provides 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-sqlite3 v0.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.asyncDispose delegates 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