@polyengine/wasi 0.5.0 → 0.6.0

package/esm/cli.js

@@ -12,7 +12,8 @@
 // tuple<stream<u8>, future<result<_, error-code>>>` (the tcp-receive
 // tuple shape) and `stdout/stderr.write-via-stream: func(data:
 // stream<u8>) -> future<result<_, error-code>>` (the tcp-send shape:
-// the async method's promise IS the future source, amendment A12); exit
+// the async method's promise IS the future source, per embedder-api.md
+// §"Streams and futures"); exit
 // gains `exit-with-code: func(status-code: u8)`, and environment's cwd
 // getter is renamed `get-initial-cwd` (0.2 spells it `initial-cwd`).
 import { InputStream, OutputStream } from "./io.js";
@@ -36,27 +37,22 @@ function concat(chunks) {
  * `exit`'s WIT signature is `exit: func(status: result)` — `result` with no
  * type parameters, i.e. `result<_, _>`. Per contracts/embedder-api.md's value
  * table, a `result` in **parameter** (non-return) position is plain nested
- * data: `{ kind: "ok" } | { kind: "err" }` (the A10 family — this comment
- * and the impl carried the pre-A10 `tag` spelling until 2026-08-14, a
- * latent bug the direct-call unit tests masked), never a throw. Only a
+ * data: `{ kind: "ok" } | { kind: "err" }` (embedder-api.md §"Naming and
+ * casing" — enum/variant case names are data, not `{tag}` wrappers),
+ * never a throw. Only a
  * function's own *return*-position result throws/rejects.
  */
 export function cli(options = {}) {
     const stdoutChunks = [];
     const stderrChunks = [];
-    const passthrough = options.passthrough ?? false;
     let exited = false;
     let exitOk;
     let exitCode;
     const stdout = new OutputStream((chunk) => {
         stdoutChunks.push(chunk);
-        if (passthrough)
-            console.log(new TextDecoder().decode(chunk));
     });
     const stderr = new OutputStream((chunk) => {
         stderrChunks.push(chunk);
-        if (passthrough)
-            console.error(new TextDecoder().decode(chunk));
     });
     const captured = {
         stdout: () => concat(stdoutChunks),
@@ -67,12 +63,11 @@ export function cli(options = {}) {
         exitOk: () => exitOk,
         exitCode: () => exitCode,
     };
-    /** 0.3 write-via-stream into a capture buffer (A12: the promise IS the future). */
-    const captureViaStream = (chunks, mirror) => async (data) => {
+    /** 0.3 write-via-stream into a capture buffer (the promise IS the future — embedder-api.md §"Streams and futures"). */
+    const captureViaStream = (chunks) => async (data) => {
         for await (const chunk of data) {
             const bytes = chunk instanceof Uint8Array ? chunk : Uint8Array.from(chunk);
             chunks.push(bytes);
-            mirror?.(new TextDecoder().decode(bytes));
         }
         return { kind: "ok" };
     };
@@ -139,10 +134,10 @@ export function cli(options = {}) {
             ],
         },
         "wasi:cli/stdout@0.3": {
-            writeViaStream: captureViaStream(stdoutChunks, passthrough ? (t) => console.log(t) : undefined),
+            writeViaStream: captureViaStream(stdoutChunks),
         },
         "wasi:cli/stderr@0.3": {
-            writeViaStream: captureViaStream(stderrChunks, passthrough ? (t) => console.error(t) : undefined),
+            writeViaStream: captureViaStream(stderrChunks),
         },
         "wasi:cli/terminal-input@0.3": { TerminalInput },
         "wasi:cli/terminal-output@0.3": { TerminalOutput },

package/esm/cli_stdio.js

@@ -18,15 +18,16 @@
 // are SYNC WIT functions. Against capture buffers they degenerate to
 // their non-blocking forms (io.ts base classes, sync fast path); against
 // a REAL stdin/stdout they must genuinely wait, which parks the calling
-// wasm frame through the suspending kernel (embedder-api A1/A2/A14 —
-// io.ts marks the blocking declarations on the REGISTERED stream
-// prototypes; these duck-typed stream impls override the behavior, and
-// per A2 the mark relays). Consequences: guests linking the blocking
-// leaves auto-select jspi mode on V8 engines, and on engines without
-// JSPI a genuine wait raises a clean `NeedsJspi` at the park site. The
-// `@0.3` track has no such dependence — its stdio is stream-shaped and
+// wasm frame through the suspending kernel (embedder-api.md §"The WASI
+// parking kernel" — io.ts marks the blocking declarations on the
+// REGISTERED stream prototypes; these duck-typed stream impls override
+// the behavior, and the mark relays). Consequences: guests linking the
+// blocking leaves auto-select jspi mode on V8 engines, and on engines
+// without JSPI a genuine wait raises a clean `NeedsJspi` at the park site.
+// The `@0.3` track has no such dependence — its stdio is stream-shaped and
 // async by construction (`read-via-stream` returns the tcp-receive
-// tuple; `write-via-stream`'s promise is the future source, A12).
+// tuple; `write-via-stream`'s promise is the future source, per
+// embedder-api.md §"Streams and futures").
 //
 // Semantics:
 //
@@ -110,7 +111,7 @@ export function cliStdio(options = {}) {
     const p2Stdout = new SinkOutputStream(stdoutSink);
     const p2Stderr = new SinkOutputStream(stderrSink);
     // 0.3 write-via-stream: drain the guest's stream to the sink; the
-    // promise is the future source (A12).
+    // promise is the future source (embedder-api.md §"Streams and futures").
     const writeViaStream = (sink) => async (data) => {
         try {
             for await (const chunk of data) {

package/esm/clocks.js

@@ -1,9 +1,9 @@
 // `wasi:clocks@0.2` + `wasi:clocks@0.3` (contracts/embedder-api.md
-// §"WASI examination"; the D-1 union clock — tools/smoke-c0/REPORT.md
-// finding D-1: `monotonic-clock@0.3.0` exposes different function sets
-// across the consumer corpus (`wait-for` vs `now`+`wait-until`) at the SAME
-// version string — same track, divergent drafts, served by one union
-// provider per contracts/embedder-api.md §"Version canonicalization").
+// §"WASI examination"; the union clock: `monotonic-clock@0.3.0` exposes
+// different function sets across the consumer corpus (`wait-for` vs
+// `now`+`wait-until`) at the SAME version string — same track, divergent
+// drafts, served by one union provider per contracts/embedder-api.md
+// §"Version canonicalization").
 // The @0.3 track also carries system-clock (0.3's wall-clock reshape) and
 // the type-only types interface, per the WASI 0.3.1 release WIT.
 import { Pollable } from "./io.js";
@@ -39,8 +39,7 @@ export function clocks(options = {}) {
             nanoseconds: 1_000_000,
         }),
     };
-    // The D-1 union provider (C0-proven shape, tools/smoke-c0/leg2_exec_model.ts):
-    // both drafts' functions live on the one `@0.3` track provider; per-leaf
+    // The union provider: both drafts' functions live on the one `@0.3` track provider; per-leaf
     // structural resolution (contracts/embedder-api.md §"Version
     // canonicalization") lets each consumer link only the subset it imports.
     const monotonic03 = {

package/esm/filesystem_node.js

@@ -13,7 +13,7 @@
 //
 // SYNC BY CONSTRUCTION: every backend op uses node's `*Sync` API, so the
 // 0.2 track's sync WIT functions are served without parking — guests run
-// in plain callback mode, no JSPI required (the A14 marks stay off; see
+// in plain callback mode, no JSPI required (the park-capable marks stay off; see
 // fs_provider.ts). The 0.3 track returns plain values from async funcs,
 // which the runtime accepts.
 //

package/esm/filesystem_web.js

@@ -13,8 +13,9 @@
 // for the enforcement site: it is the provider, not this backend).
 //
 // ASYNC BY CONSTRUCTION: every OPFS op returns a promise, so the 0.2
-// track's sync WIT descriptor methods are marked park-capable (A14, on
-// the per-call class prototypes — fs_provider.ts): a p2 guest that
+// track's sync WIT descriptor methods are marked park-capable (embedder-api.md
+// §"The WASI parking kernel", on the per-call class prototypes — fs_provider.ts):
+// a p2 guest that
 // touches the filesystem parks through the suspending kernel and needs
 // JSPI; on engines without it a genuine wait raises `NeedsJspi` at the
 // park site. The 0.3 track is async in WIT and needs no parking. (The

package/esm/http.js

@@ -23,17 +23,18 @@
 // VERSION KEYS: 0.3.x releases fold onto the `@0.3` compatibility track
 // (contracts/embedder-api.md §"Version canonicalization"), so the
 // default registration serves every released 0.3.x with one provider —
-// the same flagship track-key pattern as the rest of this package. The
-// pre-consolidation rc SNAPSHOTS (`0.3.0-rc-*`) are prereleases, which
-// resolve exact-only: a guest pinned to one names it via
-// `http({ version: "0.3.0-rc-..." })`, which re-keys the fragment at
-// that exact id instead.
+// the same flagship track-key pattern as the rest of this package. A
+// guest pinned to a pre-consolidation rc SNAPSHOT (`0.3.0-rc-*`, which
+// resolves exact-only) is out of scope for this fragment; an embedder
+// serving one re-keys the `imports` object it gets back from `http()`
+// manually (documented escape, unaffected by this fragment's surface).
 //
 // Body/trailers plumbing is the same stream+future choreography the TCP
 // provider proved: constructors return `[resource, transmission-future]`
-// (the future is a Promise — amendment A12 lowers it as the future
-// source), `consume-body` returns `[stream<u8>, trailers-future]`, and
-// guest-abandoned streams are retired by the runtime's A13 machinery
+// (the future is a Promise — embedder-api.md §"Streams and futures"
+// lowers it as the future source), `consume-body` returns
+// `[stream<u8>, trailers-future]`, and guest-abandoned streams are
+// retired by the runtime's producer-cancellation machinery
 // (`ReadableStream` sources are cancel()ed, which aborts the underlying
 // fetch body).
 //
@@ -62,7 +63,8 @@
 // Error model: `client.send` and the fallible fields/options methods
 // throw branded `ComponentException`s whose payloads use the WIT case
 // names VERBATIM (`DNS-timeout`, `TLS-protocol-error`, `internal-error` —
-// A10: case names are data, kebab-case as written, including capitals).
+// embedder-api.md §"Naming and casing": case names are data, kebab-case
+// as written, including capitals).
 // Fetch failures are TypeErrors with prose; a small sniff table maps the
 // recognizable ones and everything else is `internal-error(message)`.
 import { ComponentException, isComponentException } from "@polyengine/protocol";
@@ -142,7 +144,6 @@ const decoder = new TextDecoder();
  */
 export function http(options = {}) {
     const onCall = options.onCall ?? (() => { });
-    const v = options.version ?? HTTP_TRACK;
     const allowRequest = options.allowRequest;
     // --- fields -----------------------------------------------------------------
     class Fields {
@@ -713,8 +714,8 @@ export function http(options = {}) {
     }
     return {
         imports: {
-            [`wasi:http/types@${v}`]: { Fields, Request, RequestOptions, Response },
-            [`wasi:http/client@${v}`]: { send },
+            "wasi:http/types@0.3": { Fields, Request, RequestOptions, Response },
+            "wasi:http/client@0.3": { send },
         },
         Fields: Fields,
         Request: Request,

package/esm/internal/cli_shared.js

@@ -15,9 +15,9 @@ export class ExitError extends Error {
         this.name = "ExitError";
     }
 }
-// A9 brand: an exit unwind propagates out through the embedder and any host
+// Brand: an exit unwind propagates out through the embedder and any host
 // frames in between, so it must be recognizable across runtime copies
-// (contracts/embedder-api.md §"Module identity", issue #83).
+// (contracts/embedder-api.md §"Module identity and @polyengine/protocol", issue #83).
 defineBrand(ExitError.prototype, WASI_EXIT);
 /** `terminal-input`/`terminal-output` are opaque resources; never produced (no terminal). */
 export class TerminalInput {

package/esm/internal/fs_provider.js

@@ -12,7 +12,7 @@
 // track gets its OWN resource class per `makeFilesystem` call — a guest
 // links one track and never mixes instances.
 //
-// ERROR SHAPES (the A10 family, and the reason this file exists twice
+// ERROR SHAPES (embedder-api.md §"Naming and casing", and the reason this file exists twice
 // over): 0.2's `error-code` is an ENUM — the err payload is the bare
 // kebab-case string ("no-entry") — while 0.3's is a VARIANT (it grew
 // `other(option<string>)`) — the payload is `{ kind: "no-entry" }`.
@@ -21,7 +21,7 @@
 // code passes through untouched; an unmapped throw would be a trap, so
 // the guards map everything.
 //
-// SYNC vs PARKING (A14). 0.2 descriptor methods are sync WIT functions.
+// SYNC vs PARKING (embedder-api.md §"The WASI parking kernel"). 0.2 descriptor methods are sync WIT functions.
 // A sync backend (node) returns plain values from every op — no parking,
 // callback-mode guests work untouched. An async backend (OPFS) returns
 // promises, so every backend-touching 0.2 method is wrapped `suspending`
@@ -212,7 +212,8 @@ function hashIdentity(id) {
     };
 }
 const READ_CHUNK = 65536;
-/** 0.2 methods wrapped `suspending` for async backends (A14; module
+/** 0.2 methods wrapped `suspending` for async backends (embedder-api.md
+ * §"The WASI parking kernel"; module
  * header). Everything that touches the backend — stream CONSTRUCTION
  * stays plain (the streams themselves park via io.ts's marks). */
 const PARKED_02 = [
@@ -652,7 +653,7 @@ export function makeFilesystem(backend, preopens, access = {}) {
             })();
             return [source, done];
         }
-        /** The promise IS the future source (A12): drain the guest's stream. */
+        /** The promise IS the future source (embedder-api.md §"Streams and futures"): drain the guest's stream. */
         async writeViaStream(data, offset) {
             try {
                 requireWritable(err03);
@@ -849,7 +850,7 @@ export function makeFilesystem(backend, preopens, access = {}) {
         }
     }
     // Async backends: mark the 0.2 track's backend-touching methods
-    // park-capable on the freshly-minted prototype (module header; A14).
+    // park-capable on the freshly-minted prototype (module header; embedder-api.md §"The WASI parking kernel").
     if (!backend.isSync) {
         const proto = Descriptor02.prototype;
         for (const name of PARKED_02) {

package/esm/internal/sockets_02.js

@@ -10,16 +10,16 @@
 // `accept` returning `would-block` until `subscribe`'s pollable is ready,
 // datagram streams with `receive(max)`/`check-send`+`send` batches — and
 // wasi-libc emulates POSIX blocking by `pollable.block()` (the io.ts
-// parking kernel, A14). Socket byte I/O rides `wasi:io/streams@0.2`:
+// parking kernel, embedder-api.md §"The WASI parking kernel"). Socket byte I/O rides `wasi:io/streams@0.2`:
 // wasi-libc links the NON-blocking `input-stream.read` + `subscribe`
 // (never `blocking-read`) and `check-write`/`write`/`blocking-flush` —
 // exactly the surfaces of io.ts's async-backed `FedInputStream` /
 // `SinkOutputStream`, which this module mints over connections. The
 // PARKING therefore happens in `Pollable.block`/`poll` and
-// `blocking-flush`, all already A14-marked: 0.2 socket guests need JSPI
+// `blocking-flush`, all already park-capable-marked: 0.2 socket guests need JSPI
 // on V8 engines, like the 0.3 track's `listen`.
 //
-// 0.2's `error-code` is an ENUM (bare strings — the A10 rule), with a
+// 0.2's `error-code` is an ENUM (bare strings — embedder-api.md §"Naming and casing"), with a
 // different vocabulary than 0.3's variant: it grew `unknown`,
 // `would-block`, `not-in-progress`, `concurrency-conflict`,
 // `new-socket-limit` and the name-lookup codes, and it lacks
@@ -314,9 +314,7 @@ export function sockets02(onCall) {
             }
             let conn;
             try {
-                conn = state.listener.tryAccept === undefined
-                    ? undefined
-                    : state.listener.tryAccept();
+                conn = state.listener.tryAccept();
             }
             catch (e) {
                 raise02(e, "tcp-socket.accept");
@@ -447,7 +445,7 @@ export function sockets02(onCall) {
             }
             if (this.#state === "listening" && listen !== undefined) {
                 const l = listen.listener;
-                return new Pollable(() => l.acceptReady === undefined ? true : l.acceptReady(), () => l.waitAccept === undefined ? Promise.resolve() : l.waitAccept());
+                return new Pollable(() => l.acceptReady(), () => l.waitAccept());
             }
             return new Pollable(); // no pending operation: ready
         }
@@ -498,9 +496,6 @@ export function sockets02(onCall) {
             const conn = this.#conn;
             if (this.#state !== "connected" || conn === undefined)
                 return;
-            if (conn.setKeepAlive === undefined) {
-                throw err02("not-supported", "tcp-socket: no keep-alive control on this backend");
-            }
             try {
                 conn.setKeepAlive(this.#keepAliveEnabled, Number(this.#keepAliveIdleNs / 1000000n));
             }
@@ -612,7 +607,7 @@ export function sockets02(onCall) {
             this.#streams = streams;
             // OS-level (dis)connect, fire-and-forget: failures surface on the
             // first datagram op (doc comment above).
-            if (remoteAddress !== undefined && conn.connect !== undefined) {
+            if (remoteAddress !== undefined) {
                 void conn.connect({
                     transport: "udp",
                     hostname: ipHostname(remoteAddress),
@@ -623,7 +618,7 @@ export function sockets02(onCall) {
             }
             else if (remoteAddress === undefined && wasConnected) {
                 try {
-                    conn.disconnect?.();
+                    conn.disconnect();
                 }
                 catch {
                     // Not connected at the OS level (compat backends).
@@ -713,11 +708,11 @@ export function sockets02(onCall) {
                 return;
             try {
                 if (this.#hopLimit !== undefined)
-                    conn.setTtl?.(this.#hopLimit);
+                    conn.setTtl(this.#hopLimit);
                 if (this.#recvBuffer !== undefined)
-                    conn.setRecvBufferSize?.(Number(this.#recvBuffer));
+                    conn.setRecvBufferSize(Number(this.#recvBuffer));
                 if (this.#sendBuffer !== undefined)
-                    conn.setSendBufferSize?.(Number(this.#sendBuffer));
+                    conn.setSendBufferSize(Number(this.#sendBuffer));
             }
             catch (e) {
                 raise02(e, "udp-socket (applying cached options)");
@@ -758,7 +753,7 @@ export function sockets02(onCall) {
             while (out.length < max) {
                 let item;
                 try {
-                    item = this.#conn.tryReceive === undefined ? undefined : this.#conn.tryReceive();
+                    item = this.#conn.tryReceive();
                 }
                 catch (e) {
                     raise02(e, "incoming-datagram-stream.receive");
@@ -777,7 +772,7 @@ export function sockets02(onCall) {
         subscribe() {
             onCall("incoming-datagram-stream.subscribe");
             const conn = this.#conn;
-            return new Pollable(() => conn.receiveReady === undefined ? true : conn.receiveReady(), () => conn.waitReceive === undefined ? Promise.resolve() : conn.waitReceive());
+            return new Pollable(() => conn.receiveReady(), () => conn.waitReceive());
         }
         [Symbol.dispose]() {
             // The socket owns the OS resources; streams are views.

package/esm/internal/sockets_03.js

@@ -103,7 +103,7 @@ export function sockets03(onCall) {
              * the remote and `send` needs no explicit address. An unbound socket
              * implicitly binds to the family wildcard first (wasmtime parity).
              *
-             * SUSPENDING (A1/A2): node's `dgram.connect` settles via callback one
+             * SUSPENDING (embedder-api.md §"The WASI parking kernel"): node's `dgram.connect` settles via callback one
              * tick later, so this sync WIT func parks the calling frame for that
              * tick — the same shape as tcp `listen`.
              */
@@ -134,9 +134,6 @@ export function sockets03(onCall) {
                     }
                     this.#applyCachedOptions();
                 }
-                if (this.#conn.connect === undefined) {
-                    throw componentError({ kind: "not-supported" }, "udp-socket.connect: this host's datagram backend has no connected mode");
-                }
                 try {
                     await this.#conn.connect({
                         transport: "udp",
@@ -155,7 +152,7 @@ export function sockets03(onCall) {
                     throw componentError({ kind: "invalid-state" }, "udp-socket.disconnect: the socket is not connected");
                 }
                 try {
-                    this.#conn.disconnect?.();
+                    this.#conn.disconnect();
                 }
                 catch (e) {
                     throw mapPlatformError(e, "udp-socket.disconnect");
@@ -342,12 +339,12 @@ export function sockets03(onCall) {
                     return;
                 try {
                     if (this.#hopLimit !== undefined)
-                        conn.setTtl?.(this.#hopLimit);
+                        conn.setTtl(this.#hopLimit);
                     if (this.#recvBuffer !== undefined) {
-                        conn.setRecvBufferSize?.(Number(this.#recvBuffer));
+                        conn.setRecvBufferSize(Number(this.#recvBuffer));
                     }
                     if (this.#sendBuffer !== undefined) {
-                        conn.setSendBufferSize?.(Number(this.#sendBuffer));
+                        conn.setSendBufferSize(Number(this.#sendBuffer));
                     }
                 }
                 catch (e) {
@@ -511,11 +508,12 @@ export function sockets03(onCall) {
              * WIT: `listen: func() -> result<stream<tcp-socket>, error-code>` —
              * transitions to `listening` and returns the perpetual accept stream,
              * whose elements are connected `TcpSocket` resources (lowered as
-             * `own<tcp-socket>` — amendment A13 destroys any element the guest
-             * never takes, closing that accepted connection). An unbound socket
+             * `own<tcp-socket>` — embedder-api.md §"Streams and futures" destroys
+             * any element the guest never takes, closing that accepted connection).
+             * An unbound socket
              * implicitly binds to the family wildcard with an ephemeral port.
              *
-             * SUSPENDING (embedder-api A1/A2, the wasi:io `block` kernel): the OS
+             * SUSPENDING (embedder-api.md §"The WASI parking kernel", the wasi:io `block` kernel): the OS
              * bind is deferred one event-loop turn by `net.Server.listen` (module
              * header), so this async method awaits the settle and the runtime
              * parks the calling guest frame for that one tick. Full listener
@@ -584,7 +582,8 @@ export function sockets03(onCall) {
                         release();
                     }
                 })();
-                // The A13 producer-cancellation hook: when the guest drops the
+                // The producer-cancellation hook (embedder-api.md §"Streams and
+                // futures"): when the guest drops the
                 // stream while the loop above is PARKED in accept(), the runtime's
                 // pump invokes this — closing the listener is what unparks the
                 // accept (it rejects; classified fatal; the generator retires).
@@ -601,7 +600,8 @@ export function sockets03(onCall) {
             }
             /**
              * WIT: `send: func(data: stream<u8>) -> future<result<_, error-code>>`
-             * — a sync func; the returned promise is the future source (A12).
+             * — a sync func; the returned promise is the future source
+             * (embedder-api.md §"Streams and futures").
              * NEVER throws: the function has no error channel of its own, so every
              * failure — including the state-machine ones — resolves the future as
              * an err value. The argument stream is dropped on failure so its
@@ -660,7 +660,7 @@ export function sockets03(onCall) {
              * close — the future distinguishes them (`ok` vs `err`). Dropping the
              * stream's reader (guest SHUT_RD) stops the pump, discards queued
              * data, and settles the future ok — the canceller is the observer
-             * (the same logic as embedder-api A8's cancelRead ruling).
+             * (the same logic as embedder-api.md §"Streams and futures"'s cancelRead ruling).
              */
             receive() {
                 onCall("tcp-socket.receive");
@@ -677,7 +677,8 @@ export function sockets03(onCall) {
                     try {
                         for (;;) {
                             // The chunk is node's own buffer (no copy); it is borrowed by
-                            // the rendezvous until the peer takes it (A5), which is safe —
+                            // the rendezvous until the peer takes it (embedder-api.md
+                            // §"Streams and futures": round-trip idempotence), which is safe —
                             // each read hands back a distinct buffer.
                             let chunk;
                             try {
@@ -823,9 +824,6 @@ export function sockets03(onCall) {
                 const conn = this.#conn;
                 if (this.#state !== "connected" || conn === undefined)
                     return;
-                if (conn.setKeepAlive === undefined) {
-                    throw componentError({ kind: "not-supported" }, "tcp-socket: this host's TCP backend has no keep-alive control");
-                }
                 try {
                     conn.setKeepAlive(this.#keepAliveEnabled, Number(this.#keepAliveIdleNs / 1000000n));
                 }

package/esm/internal/sockets_platform.js

@@ -47,7 +47,7 @@
 //     `'error'` arrive later). The seam exposes that settle as
 //     `TcpListener.settled()`; the provider awaits it inside a
 //     `suspending`-marked `listen`, parking the calling guest frame for
-//     the one tick (embedder-api A1/A2 — the same kernel that serves
+//     the one tick (embedder-api.md §"The WASI parking kernel" — the same kernel that serves
 //     wasi:io's sync `block`). Full listener fidelity follows: real
 //     ephemeral addresses, real bind error codes.
 //   * dgram receive is push-shaped (`'message'` events); the adapter

package/esm/io.js

@@ -1,27 +1,24 @@
 // `wasi:io@0.2` — error, poll, streams (contracts/embedder-api.md
 // §"WASI examination").
 //
-// THE PARKING KERNEL. `pollable.block()`, `poll()` and `blocking-*` are
-// sync WIT functions that must genuinely wait — the one p2 idiom that
-// fights a JS host. This package used to ship always-ready stubs (the
-// retired "three-tier strategy", grounded in C0 finding #6: no consumer
-// leg ever called a pollable method) with real parking documented as
-// "never (c) in this package". Both halves of that ruling expired:
+// THE PARKING KERNEL (embedder-api.md §"The WASI parking kernel").
+// `pollable.block()`, `poll()` and `blocking-*` are sync WIT functions
+// that must genuinely wait — the one p2 idiom that fights a JS host.
 //
 //   * the polymorph-iroh upstream-iroh consumer class (unmodified
 //     iroh/tokio) parks its reactor in `poll()` with timer + socket
-//     pollables — the always-ready stubs don't degrade for such a guest,
-//     they LIVELOCK it (block() no-ops, reads return empty, the frame
+//     pollables — an always-ready stub wouldn't degrade for such a guest,
+//     it would LIVELOCK it (block() no-ops, reads return empty, the frame
 //     never suspends, so the event loop never turns and no host pump can
 //     ever make progress);
-//   * the runtime's suspending-import machinery (embedder-api.md A1/A2)
-//     made real parking a per-declaration capability with graceful
-//     degradation, so the kernel is ALWAYS ON rather than an opt-in
-//     profile: on engines without JSPI, `chooseMode` falls back to plain
-//     and everything behaves like the old stubs until a guest genuinely
-//     parks — which then raises a clean `NeedsJspi` at the park site
-//     instead of livelocking. Embedders wanting guaranteed-plain
-//     instantiation pass `jspi: false`.
+//   * the runtime's suspending-import machinery (embedder-api.md
+//     §"Functions and async") makes real parking a per-declaration
+//     capability with graceful degradation, so the kernel is ALWAYS ON
+//     rather than an opt-in profile: on engines without JSPI, `chooseMode`
+//     falls back to plain and everything behaves like an always-ready stub
+//     until a guest genuinely parks — which then raises a clean
+//     `NeedsJspi` at the park site instead of livelocking. Embedders
+//     wanting guaranteed-plain instantiation pass `jspi: false`.
 //
 // Costs, deliberately confined: only the park-capable declarations are
 // marked (`block`, `poll`) — hot-path `read`/`check-write` stay plain —
@@ -36,15 +33,17 @@
 // wake pattern is polymorph-iroh's shim (promise-swap edge triggering).
 //
 // Streams: `read`/`check-write` stay plain (sync, never park), but the
-// `blocking-*` declarations are MARKED park-capable (amendment A14): the
+// `blocking-*` declarations are MARKED park-capable (embedder-api.md
+// §"The WASI parking kernel"): the
 // buffer-backed base impls below always take the sync fast path, while
 // the genuinely-async impls — `FedInputStream`/`SinkOutputStream` below,
 // serving cli-stdio's host stdin/stdout and filesystem-web's OPFS files,
 // where "blocking" cannot be served from a buffer — return a Promise and
 // park the frame. Marking follows the WIT declaration on the REGISTERED
-// class's prototype (A2: instance-level overrides change behavior, not
-// suspendability), which is what lets the duck-typed async streams park
-// through the resource types registered here.
+// class's prototype (embedder-api.md §"Functions and async" —
+// "prototype declares, instances behave": instance-level overrides
+// change behavior, not suspendability), which is what lets the
+// duck-typed async streams park through the resource types registered here.
 var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
     var useValue = arguments.length > 2;
     for (var i = 0; i < initializers.length; i++) {
@@ -108,8 +107,9 @@ export class IoError {
  * A pollable over host-supplied readiness.
  *
  * WIT-facing surface: `ready()` and `block()` (the latter parks the
- * calling wasm frame when unready — @suspending, embedder-api.md A2:
- * the class prototype is the brand authority).
+ * calling wasm frame when unready — @suspending, embedder-api.md
+ * §"Functions and async": the class prototype is the brand authority
+ * ("prototype declares, instances behave").
  *
  * Host-facing surface: the constructor and `waitPromise()`. `ready` must
  * be cheap and side-effect-free; `wait` returns a promise that settles
@@ -135,7 +135,7 @@ let Pollable = (() => {
         constructor(ready = () => true, wait = () => Promise.resolve()) {
             this.#ready = ready;
             this.#wait = wait;
-            // A20 realm-local pill (contracts/embedder-api.md §"Realm boundaries
+            // realm-local pill (contracts/embedder-api.md §"Realm boundaries
             // and structured-clone-safe forms"; issue #131): stateful handles fail
             // loud at a raw structuredClone/postMessage instead of husking.
             defineRealmLocal(this);
@@ -190,7 +190,7 @@ let Pollable = (() => {
     };
 })();
 export { Pollable };
-// A9 brand (contracts/embedder-api.md §"Module identity"): pollables cross
+// brand (contracts/embedder-api.md §"Module identity and @polyengine/protocol"): pollables cross
 // into host provider code, which may resolve a different @polyengine copy. The
 // brand makes them recognizable there; same-copy `instanceof` is unchanged
 // and stays the documented spelling (issue #83). `poll()` itself needs no
@@ -275,14 +275,14 @@ let InputStream = (() => {
             }
             return out;
         }
-        /** Park-capable (A14): the buffer-backed base never parks. */
+        /** Park-capable: the buffer-backed base never parks. */
         blockingRead(len) {
             return this.read(len);
         }
         skip(len) {
             return BigInt(this.read(len).length);
         }
-        /** Park-capable (A14): the buffer-backed base never parks. */
+        /** Park-capable: the buffer-backed base never parks. */
         blockingSkip(len) {
             return this.skip(len);
         }
@@ -331,7 +331,7 @@ let OutputStream = (() => {
                 throw closedError();
             this.#sink(contents);
         }
-        /** Park-capable (A14): the never-backpressured base never parks. */
+        /** Park-capable: the never-backpressured base never parks. */
         blockingWriteAndFlush(contents) {
             this.write(contents);
         }
@@ -339,7 +339,7 @@ let OutputStream = (() => {
             if (this.#closed)
                 throw closedError();
         }
-        /** Park-capable (A14): the never-backpressured base never parks. */
+        /** Park-capable: the never-backpressured base never parks. */
         blockingFlush() {
             this.flush();
         }
@@ -349,7 +349,7 @@ let OutputStream = (() => {
         writeZeroes(len) {
             this.write(new Uint8Array(Number(len)));
         }
-        /** Park-capable (A14): the never-backpressured base never parks. */
+        /** Park-capable: the never-backpressured base never parks. */
         blockingWriteZeroesAndFlush(len) {
             this.writeZeroes(len);
         }
@@ -358,7 +358,7 @@ let OutputStream = (() => {
             this.write(chunk);
             return BigInt(chunk.length);
         }
-        /** Park-capable (A14): the never-backpressured base never parks. */
+        /** Park-capable: the never-backpressured base never parks. */
         blockingSplice(src, len) {
             return this.splice(src, len);
         }
@@ -380,7 +380,7 @@ export const STREAM_HIGH_WATER = 65536;
  * generic bridge from any `AsyncIterable<Uint8Array>` (host stdin, an
  * OPFS file read) to p2 stream semantics. `read` on an empty open stream
  * returns an empty list (p2's non-blocking contract), `blocking-read`
- * parks until bytes or EOF (A14/A2 mark relay — duck-typed against the
+ * parks until bytes or EOF (mark relay — duck-typed against the
  * registered `InputStream`, the marks relay from that prototype), and
  * EOF-with-drained-buffer is the `closed` stream-error. The feed pauses
  * past the high-water mark (no unbounded buffering).
@@ -481,7 +481,7 @@ let FedInputStream = (() => {
                 throw closedError(); // drained + ended = closed
             return new Uint8Array(0); // open, nothing available: p2 non-blocking read
         }
-        /** Parks (A14/A2 mark relay from the registered prototype). */
+        /** Parks (mark relay from the registered prototype). */
         blockingRead(len) {
             if (this.#buffered > 0 || this.#eof || this.#closed)
                 return this.read(len);
@@ -517,7 +517,7 @@ export { FedInputStream };
  * budget: `check-write` reports the remaining permit (writing past it is
  * the guest's contract violation and traps via unbranded throw),
  * `blocking-flush`/`blocking-write-and-flush` park until the sink
- * drained everything (A14/A2 mark relay), `subscribe` wakes when budget
+ * drained everything (mark relay), `subscribe` wakes when budget
  * frees. A sink failure surfaces as the `last-operation-failed`
  * stream-error carrying an `IoError`.
  *
@@ -602,7 +602,7 @@ let SinkOutputStream = (() => {
         flush() {
             this.#checkOpen();
         }
-        /** Parks until the sink drained everything (A14/A2 mark relay). */
+        /** Parks until the sink drained everything (mark relay). */
         blockingFlush() {
             this.#checkOpen();
             if (this.#queued === 0)

package/esm/mod.js

@@ -1,8 +1,8 @@
 // `@polyengine/wasi` — the WASI providers for polyengine hosts, and the
 // executable check that the embedder conventions
-// (`@polyengine/protocol`, amendment A22 — this package is protocol-only)
-// serve WASI (contracts/embedder-api.md C2
-// checklist item 7; docs/architecture.md §2 keeps implementations out of
+// (`@polyengine/protocol` — this package is protocol-only, per
+// embedder-api.md §"The host-ABI surface and its version")
+// serve WASI (docs/architecture.md §2 keeps implementations out of
 // the RUNTIME — this package is where they live). Scope: p2
 // baseline + p3 clocks + à la carte sockets on BOTH tracks (the
 // poll-shaped `@0.2` surface std::net links, and `@0.3` UDP + TCP
@@ -54,9 +54,9 @@
 // canonicalization" (`@0.2`, `@0.3`) — this package is the flagship
 // track-key-registration consumer: one `@0.2` provider serves every p2
 // leaf regardless of whether the guest's binary says `0.2.6`, `0.2.9` or
-// `0.2.12` (C0 finding D-2), and one `@0.3` union provider serves both
+// `0.2.12`, and one `@0.3` union provider serves both
 // divergent `monotonic-clock@0.3.0` drafts the corpus actually links
-// (C0 finding D-1).
+// (§"Version canonicalization").
 import { cli } from "./cli.js";
 import { clocks } from "./clocks.js";
 import { filesystem } from "./filesystem.js";

package/esm/sockets.js

@@ -101,11 +101,11 @@
 // once from `unbound` (a failed attempt closes the socket); `listen` once
 // from `unbound` (implicit wildcard-ephemeral bind) or `bound`;
 // `send`/`receive` once each, only when `connected`, and their failures
-// NEVER throw — `send`'s error channel is its returned future (amendment
-// A12: the async method's promise IS the future source) and `receive`'s
-// is the future half of its tuple, resolved as result values. `listen`
-// returns the perpetual accept stream, whose elements are connected
-// `tcp-socket` resources (amendment A13: un-taken elements are destroyed
+// NEVER throw — `send`'s error channel is its returned future (embedder-api.md
+// §"Streams and futures": the async method's promise IS the future source)
+// and `receive`'s is the future half of its tuple, resolved as result values.
+// `listen` returns the perpetual accept stream, whose elements are connected
+// `tcp-socket` resources (§"Streams and futures": un-taken elements are destroyed
 // at teardown, closing their connections); per-connection accept failures
 // are skipped, listener-fatal ones end the stream. Stream teardown
 // follows the WIT's shared-ownership note: the OS socket closes only when
@@ -117,8 +117,8 @@
 // failures while consuming `send`'s stream (a peer trap) are NOT socket
 // errors: they propagate as producer failures on the host-failure channel.
 //
-// `listen` is SUSPENDING (embedder-api A1/A2 — the wasi:io `block`
-// kernel): node defers the OS bind one event-loop turn, so `listen` parks
+// `listen` is SUSPENDING (embedder-api.md §"The WASI parking kernel" —
+// the wasi:io `block` kernel): node defers the OS bind one event-loop turn, so `listen` parks
 // the calling guest frame for that tick and returns fully settled — real
 // ephemeral addresses from `get-local-address`, real error codes
 // (`address-in-use`) from a failed bind. Guests that link `listen`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polyengine/wasi",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "WASI providers for polyengine hosts: the p2 baseline and p3 clocks, one module per semver track.",
   "homepage": "https://github.com/polymorph-components/polyengine#readme",
   "repository": {
@@ -91,7 +91,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@polyengine/protocol": "^0.2.2"
+    "@polyengine/protocol": "^0.3.0"
   },
   "_generatedBy": "dnt@0.43.2"
 }

package/types/cli.d.ts

@@ -8,8 +8,6 @@ export interface CliOptions {
     cwd?: string;
     /** `get-stdin`'s buffer contents; default empty (matches contract: "stdin (empty)"). */
     stdinBuffer?: Uint8Array;
-    /** Also `console.log`/`console.error` captured stdout/stderr writes. Default false. */
-    passthrough?: boolean;
     /** `exit()` throws `ExitError` instead of merely recording. Default false. */
     throwOnExit?: boolean;
 }
@@ -36,9 +34,9 @@ export interface CliResult {
  * `exit`'s WIT signature is `exit: func(status: result)` — `result` with no
  * type parameters, i.e. `result<_, _>`. Per contracts/embedder-api.md's value
  * table, a `result` in **parameter** (non-return) position is plain nested
- * data: `{ kind: "ok" } | { kind: "err" }` (the A10 family — this comment
- * and the impl carried the pre-A10 `tag` spelling until 2026-08-14, a
- * latent bug the direct-call unit tests masked), never a throw. Only a
+ * data: `{ kind: "ok" } | { kind: "err" }` (embedder-api.md §"Naming and
+ * casing" — enum/variant case names are data, not `{tag}` wrappers),
+ * never a throw. Only a
  * function's own *return*-position result throws/rejects.
  */
 export declare function cli(options?: CliOptions): CliResult;

package/types/http.d.ts

@@ -6,7 +6,7 @@ import { type Stream } from "@polyengine/protocol";
  * track literally, but the public entry point is `http()`.
  */
 export declare const HTTP_TRACK = "0.3";
-/** `method` — case names verbatim (A10). */
+/** `method` — case names verbatim (embedder-api.md §"Naming and casing"). */
 export type Method = {
     kind: "get";
 } | {
@@ -94,13 +94,6 @@ export type BodySource = Stream<number> | AsyncIterable<Uint8Array | number[]> |
 /** What future params accept: the lifted handle or a promise of the value. */
 export type FutureLike<T> = PromiseLike<T>;
 export interface HttpOptions {
-    /**
-     * Override the registration keys for a guest pinned to a PRERELEASE
-     * snapshot (`0.3.0-rc-*`), which the resolver matches exactly — no
-     * track exists for prereleases. Default: the `@0.3` track, serving
-     * every released 0.3.x.
-     */
-    version?: string;
     /** Observe every entry point the guest reaches (see sockets' onCall). */
     onCall?: (call: string) => void;
     /**

package/types/internal/cli_shared.d.ts

@@ -1,8 +1,7 @@
 import type { Stream } from "@polyengine/protocol";
-/** `wasi:cli/types@0.3`'s `error-code` ENUM: bare kebab-case strings (the
- * A10 value table — enums are data strings, not `{kind}` variants; this
- * type carried a `{kind}` wrapper until 2026-08-14, a latent bug no err
- * path had exercised). */
+/** `wasi:cli/types@0.3`'s `error-code` ENUM: bare kebab-case strings
+ * (embedder-api.md §"Naming and casing" — enums are data strings, not
+ * `{kind}` variants). */
 export type CliErrorCode = "io" | "illegal-byte-sequence" | "pipe";
 /** `result<_, error-code>` AS A VALUE (the 0.3 stdio futures). */
 export type CliIoResult = {

package/types/internal/fs_provider.d.ts

@@ -123,7 +123,7 @@ export interface MetadataHashValue {
     lower: bigint;
     upper: bigint;
 }
-/** 0.3 `result<_, error-code>` as a future/tuple VALUE (A12 shapes). */
+/** 0.3 `result<_, error-code>` as a future/tuple VALUE (embedder-api.md §"Streams and futures"). */
 export type FsResult03 = {
     kind: "ok";
 } | {

package/types/internal/sockets_platform.d.ts

@@ -17,25 +17,23 @@ export interface DatagramConn {
     send(p: Uint8Array, addr?: NetAddr): Promise<number>;
     receive(): Promise<[Uint8Array, NetAddr]>;
     close(): void;
-    /** OS-level connected mode (kernel filters + default destination).
-     * Optional capability: absent = the provider answers `not-supported`. */
-    connect?(addr: NetAddr): Promise<void>;
-    disconnect?(): void;
-    /** IP_TTL / IPV6_UNICAST_HOPS. Optional capability. */
-    setTtl?(ttl: number): void;
-    /** SO_RCVBUF / SO_SNDBUF. Optional capabilities. */
-    getRecvBufferSize?(): number;
-    setRecvBufferSize?(size: number): void;
-    getSendBufferSize?(): number;
-    setSendBufferSize?(size: number): void;
+    /** OS-level connected mode (kernel filters + default destination). */
+    connect(addr: NetAddr): Promise<void>;
+    disconnect(): void;
+    /** IP_TTL / IPV6_UNICAST_HOPS. */
+    setTtl(ttl: number): void;
+    /** SO_RCVBUF / SO_SNDBUF. */
+    getRecvBufferSize(): number;
+    setRecvBufferSize(size: number): void;
+    getSendBufferSize(): number;
+    setSendBufferSize(size: number): void;
     /** Non-blocking queue access + readiness (the 0.2 datagram streams:
-     * poll-shaped receive instead of the promise-shaped one above).
-     * Optional capabilities. */
-    tryReceive?(): [Uint8Array, NetAddr] | undefined;
-    receiveReady?(): boolean;
+     * poll-shaped receive instead of the promise-shaped one above). */
+    tryReceive(): [Uint8Array, NetAddr] | undefined;
+    receiveReady(): boolean;
     /** The CURRENT epoch's wake promise (promise-swap: settles when a
      * datagram arrives, the socket errors, or it closes; re-armed per event). */
-    waitReceive?(): Promise<void>;
+    waitReceive(): Promise<void>;
 }
 export type ListenDatagram = (options: {
     transport: "udp";
@@ -51,9 +49,8 @@ export interface TcpConn {
     write(p: Uint8Array): Promise<number>;
     closeWrite(): Promise<void>;
     close(): void;
-    /** SO_KEEPALIVE + TCP_KEEPIDLE (node exposes exactly this pair).
-     * Optional capability: absent = the provider answers `not-supported`. */
-    setKeepAlive?(enabled: boolean, idleMs: number): void;
+    /** SO_KEEPALIVE + TCP_KEEPIDLE (node exposes exactly this pair). */
+    setKeepAlive(enabled: boolean, idleMs: number): void;
 }
 export type TcpConnect = (options: {
     transport: "tcp";
@@ -73,11 +70,11 @@ export interface TcpListener {
     settled(): Promise<void>;
     accept(): Promise<TcpConn>;
     close(): void;
-    /** Non-blocking accept + readiness (the 0.2 poll-shaped accept).
-     * Optional capabilities; same promise-swap contract as `waitReceive`. */
-    tryAccept?(): TcpConn | undefined;
-    acceptReady?(): boolean;
-    waitAccept?(): Promise<void>;
+    /** Non-blocking accept + readiness (the 0.2 poll-shaped accept);
+     * same promise-swap contract as `waitReceive`. */
+    tryAccept(): TcpConn | undefined;
+    acceptReady(): boolean;
+    waitAccept(): Promise<void>;
 }
 export type TcpListen = (options: {
     transport: "tcp";

package/types/internal/sockets_shared.d.ts

@@ -26,7 +26,7 @@ export interface Ipv6SocketAddress {
     address: Ipv6Address;
     scopeId: number;
 }
-/** The `ip-socket-address` variant, in `{ kind, value }` form (A10). */
+/** The `ip-socket-address` variant, in `{ kind, value }` form (embedder-api.md §"Naming and casing"). */
 export type IpSocketAddress = {
     kind: "ipv4";
     value: Ipv4SocketAddress;
@@ -222,7 +222,8 @@ export type TcpSendSource = Stream<number> | AsyncIterable<Uint8Array | number[]
 export type TcpByteStream = AsyncIterable<Uint8Array> | Iterable<Uint8Array>;
 /**
  * What tcp `listen` returns: the perpetual accept stream. `cancel` is the
- * A13 producer-cancellation hook the runtime's pump invokes when the
+ * producer-cancellation hook (embedder-api.md §"Streams and futures")
+ * the runtime's pump invokes when the
  * guest drops the stream while the loop is parked in accept(); direct
  * (non-runtime) consumers may call it themselves to stop accepting.
  */
@@ -233,13 +234,13 @@ export type TcpAcceptStream = AsyncIterable<TcpSocket> & {
  * The host-implemented `tcp-socket` resource surface (client + listener
  * halves — module header). `send` is a WIT sync func returning
  * `future<result>`: the async method's promise is lowered as the future
- * source (amendment A12), so the guest's call returns immediately and the
- * future settles when transmission completes. `receive`'s tuple carries
- * the byte stream and the future that reports FIN (`ok`) vs abnormal
- * close (`err`). `listen` returns the perpetual accept stream — an
- * async iterable of connected `TcpSocket` resources, lowered as
- * `stream<own<tcp-socket>>` (amendment A13: elements the guest never
- * takes are destroyed, closing their connections). Dropping the guest
+ * source (embedder-api.md §"Streams and futures"), so the guest's call
+ * returns immediately and the future settles when transmission completes.
+ * `receive`'s tuple carries the byte stream and the future that reports
+ * FIN (`ok`) vs abnormal close (`err`). `listen` returns the perpetual
+ * accept stream — an async iterable of connected `TcpSocket` resources,
+ * lowered as `stream<own<tcp-socket>>` (§"Streams and futures": elements
+ * the guest never takes are destroyed, closing their connections). Dropping the guest
  * handle does NOT close a socket with live pumps or a live accept stream
  * (the WIT's shared-ownership note); the OS socket closes when the
  * handle and every derived stream are all retired.

package/types/io.d.ts

@@ -26,8 +26,9 @@ export declare class IoError {
  * A pollable over host-supplied readiness.
  *
  * WIT-facing surface: `ready()` and `block()` (the latter parks the
- * calling wasm frame when unready — @suspending, embedder-api.md A2:
- * the class prototype is the brand authority).
+ * calling wasm frame when unready — @suspending, embedder-api.md
+ * §"Functions and async": the class prototype is the brand authority
+ * ("prototype declares, instances behave").
  *
  * Host-facing surface: the constructor and `waitPromise()`. `ready` must
  * be cheap and side-effect-free; `wait` returns a promise that settles
@@ -86,10 +87,10 @@ export declare class InputStream {
     #private;
     constructor(buf?: Uint8Array);
     read(len: bigint): Uint8Array;
-    /** Park-capable (A14): the buffer-backed base never parks. */
+    /** Park-capable: the buffer-backed base never parks. */
     blockingRead(len: bigint): Uint8Array | Promise<Uint8Array>;
     skip(len: bigint): bigint;
-    /** Park-capable (A14): the buffer-backed base never parks. */
+    /** Park-capable: the buffer-backed base never parks. */
     blockingSkip(len: bigint): bigint | Promise<bigint>;
     subscribe(): Pollable;
     [Symbol.dispose](): void;
@@ -105,17 +106,17 @@ export declare class OutputStream {
     constructor(sink: (chunk: Uint8Array) => void);
     checkWrite(): bigint;
     write(contents: Uint8Array): void;
-    /** Park-capable (A14): the never-backpressured base never parks. */
+    /** Park-capable: the never-backpressured base never parks. */
     blockingWriteAndFlush(contents: Uint8Array): void | Promise<void>;
     flush(): void;
-    /** Park-capable (A14): the never-backpressured base never parks. */
+    /** Park-capable: the never-backpressured base never parks. */
     blockingFlush(): void | Promise<void>;
     subscribe(): Pollable;
     writeZeroes(len: bigint): void;
-    /** Park-capable (A14): the never-backpressured base never parks. */
+    /** Park-capable: the never-backpressured base never parks. */
     blockingWriteZeroesAndFlush(len: bigint): void | Promise<void>;
     splice(src: InputStream, len: bigint): bigint;
-    /** Park-capable (A14): the never-backpressured base never parks. */
+    /** Park-capable: the never-backpressured base never parks. */
     blockingSplice(src: InputStream, len: bigint): bigint | Promise<bigint>;
     [Symbol.dispose](): void;
 }
@@ -133,7 +134,7 @@ export type ByteSink = (chunk: Uint8Array) => void | Promise<void>;
  * generic bridge from any `AsyncIterable<Uint8Array>` (host stdin, an
  * OPFS file read) to p2 stream semantics. `read` on an empty open stream
  * returns an empty list (p2's non-blocking contract), `blocking-read`
- * parks until bytes or EOF (A14/A2 mark relay — duck-typed against the
+ * parks until bytes or EOF (mark relay — duck-typed against the
  * registered `InputStream`, the marks relay from that prototype), and
  * EOF-with-drained-buffer is the `closed` stream-error. The feed pauses
  * past the high-water mark (no unbounded buffering).
@@ -147,7 +148,7 @@ export declare class FedInputStream {
     #private;
     constructor(source: AsyncIterable<Uint8Array>, highWater?: number);
     read(len: bigint): Uint8Array;
-    /** Parks (A14/A2 mark relay from the registered prototype). */
+    /** Parks (mark relay from the registered prototype). */
     blockingRead(len: bigint): Uint8Array | Promise<Uint8Array>;
     skip(len: bigint): bigint;
     blockingSkip(len: bigint): bigint | Promise<bigint>;
@@ -159,7 +160,7 @@ export declare class FedInputStream {
  * budget: `check-write` reports the remaining permit (writing past it is
  * the guest's contract violation and traps via unbranded throw),
  * `blocking-flush`/`blocking-write-and-flush` park until the sink
- * drained everything (A14/A2 mark relay), `subscribe` wakes when budget
+ * drained everything (mark relay), `subscribe` wakes when budget
  * frees. A sink failure surfaces as the `last-operation-failed`
  * stream-error carrying an `IoError`.
  *
@@ -173,7 +174,7 @@ export declare class SinkOutputStream {
     checkWrite(): bigint;
     write(contents: Uint8Array): void;
     flush(): void;
-    /** Parks until the sink drained everything (A14/A2 mark relay). */
+    /** Parks until the sink drained everything (mark relay). */
     blockingFlush(): void | Promise<void>;
     /** Parks until this write (and everything before it) drained. */
     blockingWriteAndFlush(contents: Uint8Array): void | Promise<void>;