@orkestrel/mcp 0.0.28 → 0.0.29

package/dist/src/core/index.js

@@ -5,7 +5,8 @@ import { Emitter } from "@orkestrel/emitter";
 import { Tool } from "@orkestrel/tool";
 //#region src/core/constants.ts
 /**
-* Names the revision offered and defaulted to in the legacy `initialize` handshake.
+* Names the revision offered and defaulted to in the legacy `initialize` handshake,
+* `'2025-11-25'`.
 *
 * @remarks
 * This is deliberately a legacy revision, and the newest one supported. 2026-07-28 is stateless
@@ -13,12 +14,15 @@ import { Tool } from "@orkestrel/tool";
 * it is asking to negotiate a revision with no negotiation.
 */
 var MCP_HANDSHAKE_VERSION = "2025-11-25";
-/** Names the older legacy revision the optional legacy decorator accepts and an adapter can pin. */
+/**
+* Names the older legacy revision the optional legacy decorator accepts and an adapter can pin,
+* `'2025-06-18'`.
+*/
 var MCP_FALLBACK_VERSION = "2025-06-18";
-/** Names the modern revision offered by an unpinned client during discovery. */
+/** Names the modern revision offered by an unpinned client during discovery, `'2026-07-28'`. */
 var MCP_MODERN_VERSION = "2026-07-28";
 /**
-* Lists the modern MCP protocol revisions a bare server accepts and advertises.
+* Lists the modern MCP protocol revisions a bare server accepts and advertises, `2026-07-28`.
 *
 * @remarks
 * Frozen in discovery-advertisement order. Legacy revisions are absent because
@@ -26,7 +30,10 @@ var MCP_MODERN_VERSION = "2026-07-28";
 * decorator own them.
 */
 var SUPPORTED_MODERN_PROTOCOL_VERSIONS = Object.freeze([MCP_MODERN_VERSION]);
-/** Lists the protocol revisions accepted by the optional legacy decorator. */
+/**
+* Lists the protocol revisions accepted by the optional legacy decorator, `2025-11-25` and
+* `2025-06-18`.
+*/
 var SUPPORTED_LEGACY_PROTOCOL_VERSIONS = Object.freeze([MCP_HANDSHAKE_VERSION, MCP_FALLBACK_VERSION]);
 /**
 * Lists the protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy
@@ -47,8 +54,8 @@ var MCP_META_SUBSCRIPTION = "io.modelcontextprotocol/subscriptionId";
 * Names the reserved extension key identifying the stable Tasks extension.
 *
 * @remarks
-* The ONE spelling of it in this package, and the identity of the immutable snapshot dated
-* 2026-07-28 this package implements. A client declares it per REQUEST, under
+* The one spelling of it in this package, and the identity of the immutable snapshot dated
+* 2026-07-28 this package implements. A client declares it per request, under
 * `_meta['io.modelcontextprotocol/clientCapabilities'].extensions`; a server advertises it
 * under `server/discover`'s `capabilities.extensions`. Both sides carry an empty object —
 * the extension defines no options, so presence is the entire declaration.
@@ -58,10 +65,10 @@ var MCP_EXTENSION_TASKS = "io.modelcontextprotocol/tasks";
 * Names the opening marker of the Base64 sentinel a standard MCP header value travels in.
 *
 * @remarks
-* The markers are LOWERCASE and exact, and this constant with {@link MCP_SENTINEL_SUFFIX} is
-* their ONE spelling in this package: {@link import('@orkestrel/mcp').encodeSentinel} builds a
+* The markers are lowercase and exact, and this constant with {@link MCP_SENTINEL_SUFFIX} is
+* their one spelling in this package: {@link import('@orkestrel/mcp').encodeSentinel} builds a
 * sentinel from them and {@link import('@orkestrel/mcp').decodeSentinel} recognizes one by
-* them, so the two directions cannot drift apart.
+* them, so the directions cannot drift apart.
 */
 var MCP_SENTINEL_PREFIX = "=?base64?";
 /** Names the closing marker of the Base64 sentinel a standard MCP header value travels in. */
@@ -80,7 +87,7 @@ var MCP_PARAM_PREFIX = "Mcp-Param-";
 * Names the Streamable-HTTP transport header that carries the MCP session id.
 *
 * @remarks
-* A STATEFUL server sends it on the `initialize` reply, and
+* A stateful server sends it on the `initialize` reply, and
 * {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} echoes it as a
 * request header on every subsequent request, so a client passes that server's session
 * validation unchanged.
@@ -113,7 +120,7 @@ var MCP_NAME_HEADER = "mcp-name";
 * Identifies the tool-schema annotation key naming the header one parameter projects into.
 *
 * @remarks
-* It is valid ONLY on a primitive property schema statically reachable from the `inputSchema`
+* It is valid only on a primitive property schema statically reachable from the `inputSchema`
 * root through `properties` keys alone. An occurrence anywhere else — under `items`, a
 * composition or conditional keyword, or a `$ref` target — makes the whole tool definition
 * invalid, which is what {@link import('@orkestrel/mcp').buildHeaderParameters} decides.
@@ -157,7 +164,7 @@ var MCP_HEADER_MISMATCH = -32020;
 * declared.
 *
 * @remarks
-* The GENERIC code for the whole condition, not one capability's code. This server answers
+* The generic code for the whole condition, not one capability's code. This server answers
 * it in more than one place — a `tools/call` that needs `elicitation`, and a `tasks/*` request
 * whose client never declared `io.modelcontextprotocol/tasks` — and they are told apart by
 * `error.data.requiredCapabilities` alone (`{ elicitation: {} }` against
@@ -204,7 +211,7 @@ var DEFAULT_MCP_LIMITS = Object.freeze({
 * Holds the one empty argument record every argument-less modern `tools/call` runs with.
 *
 * @remarks
-* Frozen and null-prototype, and SHARED: two calls that name no `arguments` receive the same
+* Frozen and null-prototype, and shared: two calls that name no `arguments` receive the same
 * reference, so nothing a tool writes into its own `arguments` can survive into the next
 * call — the write fails instead. That failure is a tool-domain failure like any other: the
 * registry isolates it into a `success: false` result, which reaches the peer as an
@@ -228,7 +235,7 @@ var JSONRPC_INVALID_PARAMS = -32602;
 * valid request.
 *
 * @remarks
-* The code every MODERN internal fault answers with — a provider, handler, continuation,
+* The code every modern internal fault answers with — a provider, handler, continuation,
 * capacity, stream-source, normalization, or serialization failure the server contained.
 * It is detail-free on the wire: the caught value reaches the application through the
 * server's `error` event and never through the response.
@@ -238,7 +245,7 @@ var JSONRPC_INTERNAL_ERROR = -32603;
 * Names the JSON-RPC 2.0 implementation-defined server error (the `-32000` to `-32099` range).
 *
 * @remarks
-* Retained for the LEGACY branch alone. A modern fault answers
+* Retained for the legacy branch alone. A modern fault answers
 * {@link JSONRPC_INTERNAL_ERROR}; this code survives only where an old-wire peer was
 * already characterized against it.
 */
@@ -437,19 +444,19 @@ function snapshotToolResult(value, limits) {
 *
 * @remarks
 * Total — a non-message returns `undefined`, never throws. The input must
-* ALREADY be `JSON.parse`d: the raw-string parse (which can throw on malformed
+* already be `JSON.parse`d: the raw-string parse (which can throw on malformed
 * JSON) happens in `MCPServer.handle` inside a try/catch that maps a parse failure
 * to a `-32700` response.
 *
-* A defined result is an OWNED CANONICAL SNAPSHOT, never the input reference: it is
+* A defined result is an owned canonical snapshot, never the input reference: it is
 * rebuilt from the canonical text and deeply frozen, so `-0` arrives as `0`. Every record
-* was SERIALIZED with its keys sorted, but the rebuilt object enumerates its own keys the
+* was serialized with its keys sorted, but the rebuilt object enumerates its own keys the
 * way JavaScript does, so an integer-like `'9'` still precedes `'10'`: the result's key
 * order is neither promised nor generally the canonical one. A caller who needs canonical
-* BYTES takes them from `serializeJSON`/`snapshotJSON` rather than re-stringifying this
+* bytes takes them from `serializeJSON`/`snapshotJSON` rather than re-stringifying this
 * result. Identity is not preserved and is not promised.
 *
-* The parser's sound partner is the COMPOSITE `isJSONRPCMessage(value) &&
+* The parser's sound partner is the composite `isJSONRPCMessage(value) &&
 * isBoundedJSON(value, limits)`, and against it both halves of the soundness law
 * hold by construction:
 *
@@ -457,12 +464,12 @@ function snapshotToolResult(value, limits) {
 *   is applied to the exact frozen reference returned.
 * - Every input satisfying the composite is admitted rather than rejected, because
 *   `isBoundedJSON` is this parser's own admission test — the same canonical
-*   serializer under the same `limits` — so the two cannot disagree about the bound.
+*   serializer under the same `limits` — so they cannot disagree about the bound.
 *
-* {@link isJSONRPCMessage} ALONE is not that partner. It is clone-backed and so already
+* {@link isJSONRPCMessage} Alone is not that partner. It is clone-backed and so already
 * exact about shape, but it carries no size or depth bound — so guard-valid values
 * exist that this parser rejects: a message nested deeper than `limits.depth`, and one
-* whose canonical text exceeds `limits.bytes`. Those are named causes, NOT a complete
+* whose canonical text exceeds `limits.bytes`. Those are named causes, not a complete
 * boundary. Among values `isJSONRPCMessage` already admits, the admitted set is exactly
 * what canonical serialization accepts under `limits`, so a caller who needs that line
 * tests it with `isBoundedJSON` rather than inferring it from this list.
@@ -492,7 +499,7 @@ function parseJSONRPCMessage(value, limits = {
 * This is the validity step after {@link isModernRequest}: a defined result can
 * only come from a guard-positive request, while a guard-positive request returns
 * `undefined` when its required modern metadata is malformed — and also when the
-* request falls outside the bound this parser INHERITS by routing through
+* request falls outside the bound this parser inherits by routing through
 * {@link parseJSONRPCMessage} under the same `limits`. The version
 * must be a string but need not be supported; unsupported strings belong to the
 * dedicated protocol-version error path. Client identity is optional, but when
@@ -541,11 +548,11 @@ function parseRequestContext(value, limits = {
 * @remarks
 * This parser does not open the opaque continuation carrier; the configured
 * continuation port performs that boundary first. The protected
-* payload binds the authenticated principal, absolute expiry, ORIGINAL request id, version,
+* payload binds the authenticated principal, absolute expiry, original request id, version,
 * method, the exact round that was issued, tool name, argument digest, and optional
 * application state. Every member is required except application state: a payload missing its
 * round cannot have the client's answers enforced, so it is refused rather than admitted
-* unenforced. An EMPTY round is refused for the same reason — a retry against it would answer
+* unenforced. An empty round is refused for the same reason — a retry against it would answer
 * no question at all. Total over malformed or hostile input.
 *
 * @param value - The opened canonical continuation value to parse
@@ -625,7 +632,7 @@ function supportsFormElicitation(value) {
 * Computes the capabilities one round of input requests needs and the client did not declare.
 *
 * @remarks
-* The protocol's rule is about SENDING: a server never issues a request kind the client's
+* The protocol's rule is about sending: a server never issues a request kind the client's
 * declared capabilities exclude. So this reads the round rather than the method, and it
 * answers with the refusal's own payload — the `requiredCapabilities` record a
 * `MissingRequiredClientCapability` error carries, keyed by each missing capability, in the
@@ -637,7 +644,7 @@ function supportsFormElicitation(value) {
 * recognize needs nothing, because {@link import('./validators.js').isMCPInputRequestMap}
 * has already refused the round it would have travelled in. Total over hostile input.
 *
-* The `elicitation` value names the ARM the round needs, so a client can act on the refusal
+* The `elicitation` value names the arm the round needs, so a client can act on the refusal
 * by declaring exactly what the payload asks for. A missing URL arm answers `{ url: {} }`, a
 * missing form arm answers the empty record this package reads as form-only, and a round
 * needing both answers `{ form: {}, url: {} }`. An empty record for a URL round would name
@@ -688,14 +695,14 @@ function computeMissingCapabilities(requests, capabilities) {
 *
 * @remarks
 * The declaration lives at `extensions['io.modelcontextprotocol/tasks']` and the schema
-* types its value EXACTLY EMPTY — `Record<string, never>`, an object with no additional
+* types its value exactly empty — `Record<string, never>`, an object with no additional
 * properties. So the key's presence is the whole declaration, and the value carries the
 * whole of the check: a `true` or a string there is a client speaking a different protocol
 * rather than a shorthand, and a member inside the object is a client declaring an option
 * this extension does not define. Both are refused, because a server that accepted either
 * would be reading a shape no peer can produce from the snapshot's own schema.
 *
-* A client declares this PER REQUEST. Nothing here consults a session, because the modern
+* A client declares this per request. Nothing here consults a session, because the modern
 * revision is stateless and a capability declared once at connect time says nothing about
 * the request in hand. Total over hostile input.
 *
@@ -976,7 +983,7 @@ function buildProgressNotification(token, progress) {
 * Builds one official cancellation notification for a request already sent.
 *
 * @remarks
-* `requestId` and `reason` are WIRE SPELLINGS carried verbatim from the dated schema's
+* `requestId` and `reason` are wire spellings carried verbatim from the dated schema's
 * `CancelledNotificationParams`, and so is the `cancelled` in the method name — this
 * package's own vocabulary says `abort`, but the method is the protocol's and does not
 * change. The notification is FIRE-AND-FORGET in the strongest sense: it carries no id,
@@ -1014,7 +1021,7 @@ function buildCancelledNotification(id, reason) {
 * Determines whether one method may answer with a given modern `resultType`.
 *
 * @remarks
-* The dated protocol lets a `tools/call` answer in more than one way — it COMPLETED, it became a
+* The dated protocol lets a `tools/call` answer in more than one way — it completed, it became a
 * durable task, or it needs another round trip — while every other method this client
 * issues has exactly one legal answer. So the arm a peer chose is only meaningful beside
 * the method it answers, and this is the one place that pairing is decided.
@@ -1043,9 +1050,9 @@ function matchesResultType(method, resultType) {
 * Concatenates an MCP tool-call result's text content blocks into one string.
 *
 * @remarks
-* The inverse of a server splitting a value into text block(s), and TOTAL: a non-record
+* The inverse of a server splitting a value into text block(s), and total: a non-record
 * result, a non-array `content`, or a non-string `text` contributes nothing rather than
-* throwing. What it returns is a RENDERING — the prose a model reads — and not the tool's
+* throwing. What it returns is a rendering — the prose a model reads — and not the tool's
 * value, which travels as `structuredContent` whenever the peer sent one.
 *
 * @param result - The unknown result payload to read content blocks from
@@ -1072,12 +1079,12 @@ function extractContentText(result) {
 * the arms the protocol gives a shape to, and deriving the tool's value from the one it
 * does not:
 *
-* - A peer's `structuredContent` is PREFERRED over the content blocks, because it is the
+* - A peer's `structuredContent` is preferred over the content blocks, because it is the
 *   tool's value in its original structure while the blocks are a rendering beside it. Its
 *   mere presence decides — an explicit `null` is a value the tool returned, not an absence.
 * - With no structured value the legacy shape applies: the value was JSON-serialized into
 *   the text block(s), so parse them and fall back to the raw string when they are not JSON.
-* - A remote tool FAILURE (`isError: true`) THROWS the error text, so an agent's tool
+* - A remote tool failure (`isError: true`) throws the error text, so an agent's tool
 *   registry isolates it into a failure result exactly as it would a local throw.
 *
 * @param name - The tool's name, used only to describe a failure that carried no text
@@ -1159,14 +1166,14 @@ function buildJSONRPCResult(id, result) {
 * as an `error` object.
 *
 * @remarks
-* An `undefined` `id` is OMITTED from the envelope rather than serialized as `null`:
+* An `undefined` `id` is omitted from the envelope rather than serialized as `null`:
 * MCP overrides the base specification here, so a peer that could not have its id
 * read receives a response with no `id` member at all.
 *
 * @param id - The failed request's id, or `undefined` when none could be read
 * @param code - One of the reserved JSON-RPC codes (see `./constants.js`)
 * @param message - A short human description of the failure
-* @param data - An OPTIONAL machine-readable payload (omitted from the envelope when absent)
+* @param data - An optional machine-readable payload (omitted from the envelope when absent)
 * @returns The error response envelope
 */
 function buildJSONRPCError(id, code, message, data) {
@@ -1188,11 +1195,11 @@ function buildJSONRPCError(id, code, message, data) {
 * receives.
 *
 * @remarks
-* The ONE place a cancellation signal is resolved. A caller may have no signal to
+* The one place a cancellation signal is resolved. A caller may have no signal to
 * offer; a dispatched method always has one to observe, so a missing signal becomes
 * a real signal rather than an absence every downstream handler would have to case on.
 *
-* The resolved signal is the request's LIFETIME, which is strictly wider than the
+* The resolved signal is the request's lifetime, which is strictly wider than the
 * caller's: it composes the caller's signal, when there is one, with the `lifetime`
 * dispatch owns and aborts once the answer this request produced is finished. That is
 * what wakes a stream producer parked on an event that will never arrive after its
@@ -1445,7 +1452,7 @@ function buildSubscriptionResult(id, identity) {
 * `capabilities.resources` and `capabilities.prompts` appear only for servers with their
 * respective managers and derive notification flags from the configured subscription filter.
 * `capabilities.completions` is independent and appears only with a completion provider.
-* `capabilities.extensions` appears only for a server that CONFIGURED the extension it
+* `capabilities.extensions` appears only for a server that configured the extension it
 * would name. An advertisement is a promise a client is entitled to act on, so a server
 * with no `task` policy omits the member entirely rather than advertising an empty
 * record — and its discovery answer stays byte-for-byte what it was before the extension
@@ -1501,7 +1508,7 @@ function buildInitializeResult(name, version, requested) {
 * before it hands the string on.
 *
 * @remarks
-* The bound is checked FIRST, against the raw string, so an oversized message is never
+* The bound is checked first, against the raw string, so an oversized message is never
 * parsed at all: a decoder that parses before it measures has already spent the work
 * the bound exists to refuse. A message over the bound, malformed JSON, and a well-formed
 * value that is not a JSON-RPC message are one answer — `undefined` — because a binder does
@@ -1528,12 +1535,12 @@ function decodeBoundedMessage(message, limits) {
 * Decodes one inbound frame and delivers it onto a transport emitter as `message` or `error`.
 *
 * @remarks
-* The ONE inbound fold every message-carrying transport in this package runs: parse the frame,
+* The one inbound fold every message-carrying transport in this package runs: parse the frame,
 * narrow it with `parseJSONRPCMessage`, emit `message` for a well-formed
 * {@link JSONRPCMessage}, and emit `error` for anything else. Total — an adversarial frame
 * produces an `error` emission and never a throw.
 *
-* The two failures report differently on purpose. Unparsable text emits the CAUGHT parse
+* The failures report differently on purpose. Unparsable text emits the caught parse
 * error, which names the offending position; well-formed JSON that is not a JSON-RPC message
 * has no caught value to report, so it emits `fault` — the carrier's own wording, passed in
 * rather than forked into a second copy of this body.
@@ -1585,15 +1592,15 @@ function decodeEvent(data) {
 }
 /**
 * Decodes a `fetch` Response's Server-Sent-Events body into the JSON-RPC messages it
-* carried — the CLIENT-side inverse of a server's Streamable-HTTP SSE response.
+* carried — the client-side inverse of a server's Streamable-HTTP SSE response.
 *
 * @remarks
 * Reads the whole `response.body` stream chunk-by-chunk through a `TextDecoder({ stream: true
 * })` (handling a multi-byte character split across reads) and `@orkestrel/sse`'s
 * {@link SSEParserInterface} (handling a partial line or in-progress event split across
 * reads), then narrows each dispatched event's `data` to a {@link JSONRPCMessage} through
-* {@link decodeEvent} (so a non-message or non-JSON `data:` event is DROPPED, never thrown —
-* total). It reuses the SAME `SSEParser` a server's `createStream` seam serializes against, so
+* {@link decodeEvent} (so a non-message or non-JSON `data:` event is dropped, never thrown —
+* total). It reuses the same `SSEParser` a server's `createStream` seam serializes against, so
 * the wire round-trips. A `null` body (no stream) yields no messages;
 * {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} reads a
 * request/response SSE reply (the server sends one `data:` event then ends), so this drains to
@@ -1660,7 +1667,7 @@ function buildResponseError(response, type) {
 * second spelling of a byte, so it is refused: `=?base64?QR==?=` reaches for the byte
 * `=?base64?QQ==?=` spells canonically, and only the canonical spelling decodes. A malformed
 * payload answers `undefined` rather than falling back to the literal, because the protocol
-* requires a server to REJECT invalid characters, and a fallback would admit the very value
+* requires a server to reject invalid characters, and a fallback would admit the very value
 * the rule exists to refuse. A value missing either marker is a literal and comes back
 * unchanged.
 *
@@ -1706,7 +1713,7 @@ function decodeSentinel(value) {
 *
 * @remarks
 * The exact inverse of {@link decodeSentinel}, and its membership rule is stated as that
-* inverse rather than as a second list that could drift: a value travels LITERALLY when it is
+* inverse rather than as a second list that could drift: a value travels literally when it is
 * plain printable ASCII — every code point in `U+0020`–`U+007E`, the RFC 9110 field-value
 * range this package admits — and {@link decodeSentinel} gives it back unchanged. Every other
 * value travels wrapped in {@link MCP_SENTINEL_PREFIX} and {@link MCP_SENTINEL_SUFFIX}, the
@@ -1746,7 +1753,7 @@ function encodeSentinel(value) {
 *
 * @remarks
 * The companion of {@link extractHeaderAnnotations}, which reads only the annotations a
-* `properties` chain reaches. Comparing the two answers is how
+* `properties` chain reaches. Comparing the answers is how
 * {@link buildHeaderParameters} decides reachability without a second walk that would have
 * to re-state which JSON Schema keywords are traversable: an annotation the reachable walk
 * did not read is one sitting under `items`, a composition or conditional keyword, a `$ref`
@@ -1790,12 +1797,12 @@ function countHeaderAnnotations(value) {
 * Reachability is the protocol's own rule: an annotation counts only where a chain of
 * `properties` keys leads to it from the `inputSchema` root, so `path` is both the schema
 * position and the position the call's `arguments` carry the value at. A property named
-* `items` is reachable like any other, because the chain is read by key POSITION rather than
+* `items` is reachable like any other, because the chain is read by key position rather than
 * by key name.
 *
 * `undefined` means the definition is invalid rather than empty: a reachable annotation whose
 * value is not an {@link import('./validators.js').isFieldToken} token, one sitting on the
-* schema ROOT (which is no property), one on a leaf whose declared type is not an
+* schema root (which is no property), one on a leaf whose declared type is not an
 * {@link import('./validators.js').isMCPHeaderPrimitive} primitive, or a chain deeper than
 * `DEFAULT_MCP_LIMITS.depth` — which is also what makes a self-referential schema terminate.
 * A node that is not a record carries nothing and answers an empty list, because a leaf the
@@ -1839,8 +1846,8 @@ function extractHeaderAnnotations(schema, path) {
 *
 * @remarks
 * The single decision both sides of the protocol make about an annotated tool: an HTTP
-* CLIENT excludes a definition this refuses from the `tools/list` result it delivers, and a
-* SERVER recognizes exactly the `Mcp-Param-*` names this returns for its own definitions.
+* client excludes a definition this refuses from the `tools/list` result it delivers, and a
+* server recognizes exactly the `Mcp-Param-*` names this returns for its own definitions.
 *
 * `undefined` means the definition is invalid, and every rule the protocol states produces
 * it: a value that is not an RFC 9110 token, a non-primitive or untyped annotated leaf, a
@@ -1877,11 +1884,11 @@ function buildHeaderParameters(schema) {
 * Renders one projected argument as the text its `Mcp-Param-*` header carries.
 *
 * @remarks
-* The protocol's conversion table, and the ONE place it is stated: a string travels as
+* The protocol's conversion table, and the one place it is stated: a string travels as
 * itself, an integer in decimal, and a boolean as lowercase `true` or `false`. The value's
 * runtime shape must match the leaf's declared type, so a schema that declares `integer` and
 * an argument that supplies a string, a fraction, or a magnitude outside the IEEE 754 safe
-* range carries NOTHING — a header that cannot round-trip the body value is worse than an
+* range carries nothing — a header that cannot round-trip the body value is worse than an
 * absent one, and the tool's own argument validation owns the disagreement.
 *
 * @param value - The argument value read at the parameter's path
@@ -1966,7 +1973,7 @@ function extractToolSchema(response, name) {
 * {@link buildCancelledNotification}.
 *
 * @remarks
-* `requestId` is the WIRE SPELLING carried verbatim from the dated schema, and it must be a
+* `requestId` is the wire spelling carried verbatim from the dated schema, and it must be a
 * real {@link JSONRPCId}: `null` is not one, and neither is an absent member, so a
 * malformed frame reads as "cancels nothing" rather than as an error. Anything that is not a
 * `notifications/cancelled` notification — a response, a request that happens to use the
@@ -1987,14 +1994,14 @@ function readCancelledId(message) {
 }
 /**
 * Pumps a controlled serialized exchange onto a transport — every notification in order, then
-* the terminating response — and END the exchange however the pump leaves.
+* the terminating response — and end the exchange however the pump leaves.
 *
 * @remarks
 * The generator's `return` value is a message like any other on the wire: it is sent
-* LAST and closes the exchange. Sends are awaited one at a time so the transport
+* last and closes the exchange. Sends are awaited one at a time so the transport
 * receives the sequence in the order the method produced it.
 *
-* The first parameter is the CONTROLLED arm rather than a bare
+* The first parameter is the controlled arm rather than a bare
 * {@link import('./types.js').MCPTextStream}, and that is the whole point of it: this pump is
 * an owner, and an owner needs a lifecycle member to discharge its obligation with. A bare
 * generator has none, so an exit where nothing was cancelled — a `send` that threw two
@@ -2004,7 +2011,7 @@ function readCancelledId(message) {
 * is a no-op for an exchange that already ended on its terminal.
 *
 * The `finally` is spelled explicitly rather than with `await using` because this package's
-* declared Node floor cannot PARSE `await using` — `target: ESNext` emits the declaration
+* declared Node floor cannot parse `await using` — `target: ESNext` emits the declaration
 * verbatim, and a floor engine rejects the whole module at load. The obligation discharged is
 * identical either way.
 *
@@ -2039,36 +2046,36 @@ async function sendStream(stream, transport) {
 * `server.handle` already turns a malformed message into a serialized `-32700` /
 * `-32600` reply and a notification into `undefined` (no reply), so this binder parses
 * nothing the server would parse differently: it decodes each inbound message through
-* {@link decodeBoundedMessage} under `server.limit`, the SERVER'S OWN bound, so a message
+* {@link decodeBoundedMessage} under `server.limit`, the server's own bound, so a message
 * the server would refuse is never parsed here either and still receives its `-32700` from
-* the one place that words it. A HELD-OPEN reply arrives as an
+* the one place that words it. A held-open reply arrives as an
 * {@link import('./types.js').MCPTextStreamControllerInterface} instead of a string: this is
 * the one place that pumps it, writing each notification in order and then the generator's
 * returned terminating response ({@link sendStream}). A `transport.send` throw or rejection —
 * mid-stream included — is caught and routed
 * to `server.emitter`'s `error` event (never rethrown, never an unhandled rejection);
 * a listener on that event that itself throws is swallowed (the end of the line —
-* the caller's own bug, never this binder's). A fault raised AFTER its own request was
+* the caller's own bug, never this binder's). A fault raised after its own request was
 * cancelled reports nothing, because a cancellation is not a fault.
 *
-* **This binder OWNS every exchange it starts, and ends each one on every exit.** It holds one
+* **This binder owns every exchange it starts, and ends each one on every exit.** It holds one
 * `AbortController` per live request, keyed by the request's id and deleted whenever that
 * request leaves — normally, by a throw, or by cancellation — and it supplies that signal to
 * `handle` as {@link import('./types.js').MCPDispatchOptions}. These consequences follow.
-* An inbound `notifications/cancelled` ABORTS the request it names, which is how the message-
+* An inbound `notifications/cancelled` aborts the request it names, which is how the message-
 * based cancellation path reaches a tool on the carriers that have one (stdio, WebSocket,
-* `MessagePort`); a cancelled request writes NO response, because a peer that asked for a call
+* `MessagePort`); a cancelled request writes no response, because a peer that asked for a call
 * to stop is not answered by it; and the transport's `closed` signal aborts every request
 * still in flight, so an exchange being pumped when the carrier dies ends with it instead of
 * writing into a socket nobody is holding.
 *
-* `listen`/`closed` are REPLACE semantics (§ port contract): the returned unbind
-* DETACHES by replacing this binder's own handlers with no-ops, so a subsequent
-* `bindServer` call on the SAME transport is never double-dispatched by a stale
+* `listen`/`closed` are replace semantics (§ port contract): the returned unbind
+* detaches by replacing this binder's own handlers with no-ops, so a subsequent
+* `bindServer` call on the same transport is never double-dispatched by a stale
 * subscription left behind — an unbind→rebind cycle yields exactly one reply per
 * request. Unbinding is itself an owner exit: it aborts and retires every request still in
 * flight before detaching, so `unbind()` then `close()` and `close()` then `unbind()` end the
-* same exchanges. It does NOT close the transport; that remains the caller's decision.
+* same exchanges. It does not close the transport; that remains the caller's decision.
 *
 * @param server - The transport-agnostic server to dispatch inbound messages over
 * @param transport - The duplex channel to pipe the server over
@@ -2128,7 +2135,7 @@ function bindServer(server, transport) {
 }
 /**
 * Pipes an {@link MCPTransportInterface} into an {@link MCPClientInterface} — every
-* inbound message is decoded and delivered onto the client's OWN transport
+* inbound message is decoded and delivered onto the client's own transport
 * (`client.transport.emitter`'s `message` / `close` events), resolving/rejecting the
 * client's correlated pending requests exactly as a direct reply would.
 *
@@ -2136,30 +2143,30 @@ function bindServer(server, transport) {
 * The client's outbound writes flow through `client.transport.send` — its existing,
 * unmodified request/response correlation — so `client` must have been constructed
 * with a {@link import('./types.js').MCPMessageTransportInterface} that itself carries
-* the SAME `transport` (see {@link import('./factories.js').createDuplexClientTransport},
+* the same `transport` (see {@link import('./factories.js').createDuplexClientTransport},
 * the additive factory that adapts an {@link MCPTransportInterface} into that shape);
 * this binder then completes the inbound half by decoding each message and pushing it
 * onto `client.transport.emitter` (an {@link import('@orkestrel/emitter').EmitterInterface}
 * exposes `emit`, so no client modification is needed). A malformed / non-JSON-RPC
-* inbound message is DROPPED (total — never throws); a delivery fault is routed to
+* inbound message is dropped (total — never throws); a delivery fault is routed to
 * `client.transport.emitter`'s `error` event (never rethrown). The returned unbind
-* DETACHES this binder (further inbound messages and the transport's `closed` signal are
-* ignored) WITHOUT closing the transport.
+* detaches this binder (further inbound messages and the transport's `closed` signal are
+* ignored) without closing the transport.
 *
-* `listen`/`closed` are REPLACE semantics (§ port contract): the returned unbind
-* DETACHES by replacing this binder's own handlers with no-ops, so a subsequent
-* `bindClient` call on the SAME transport is never double-dispatched by a stale
+* `listen`/`closed` are replace semantics (§ port contract): the returned unbind
+* detaches by replacing this binder's own handlers with no-ops, so a subsequent
+* `bindClient` call on the same transport is never double-dispatched by a stale
 * subscription left behind — an unbind→rebind cycle delivers exactly one `message`
 * emit per inbound reply.
 *
 * **This binder needs no live-request registry, and the asymmetry with {@link bindServer} is
-* real rather than an omission.** A server binder holds the lifetime of work it STARTED, so an
+* real rather than an omission.** A server binder holds the lifetime of work it started, so an
 * inbound `notifications/cancelled` has something to reach; a client binder starts no work —
 * `MCPClient` already owns its pending entries and already writes the cancellation frame
 * itself when a caller's `signal` aborts, on a carrier declaring `duplex`. Adding a registry
-* here would be a second correlation table for ids the client is already correlating, and two
-* tables for one fact drift. The one obligation this binder does carry is delivery: a
-* malformed / non-JSON-RPC inbound message is DROPPED (total — never throws).
+* here would be a second correlation table for ids the client is already correlating, and a
+* pair of tables for one fact drift. The one obligation this binder does carry is delivery: a
+* malformed / non-JSON-RPC inbound message is dropped (total — never throws).
 *
 * @param client - The transport-agnostic client whose transport to deliver messages onto
 * @param transport - The duplex channel to pipe the client over
@@ -2243,8 +2250,8 @@ function isMCPResultMetaObject(value) {
 * subscription id.
 *
 * @remarks
-* The reserved key is OPTIONAL, so a frame delivered outside a `subscriptions/listen`
-* stream passes with no stamp at all. When the key IS present its value must be a valid
+* The reserved key is optional, so a frame delivered outside a `subscriptions/listen`
+* stream passes with no stamp at all. When the key is present its value must be a valid
 * {@link JSONRPCId}, because a stamp naming nothing addressable is worse than no stamp.
 *
 * @param value - The unknown value to inspect
@@ -2411,7 +2418,7 @@ function isAbsoluteURI(value) {
 * Determines whether a value is one RFC 3339 `full-date` naming a real calendar day.
 *
 * @remarks
-* RFC 3339 §5.6 defines `date-mday` as `01-28`, `29`, `30`, or `31` BASED ON the month and
+* RFC 3339 §5.6 defines `date-mday` as `01-28`, `29`, `30`, or `31` based on the month and
 * year, so the grammar is not satisfied by shape alone: `2026-02-30` and `2025-02-29` are
 * well-formed triples that name no day, and a downstream `new Date` rolls each of them
 * silently onto a different date rather than refusing it. February's length follows the
@@ -2419,7 +2426,7 @@ function isAbsoluteURI(value) {
 *
 * The check is pure integer arithmetic on the matched fields and never constructs a `Date`,
 * because `Date` is exactly the component that performs the rollover this guard exists to
-* refuse. It is a SYNTAX guard: no time zone, locale, calendar era, or leap second applies.
+* refuse. It is a syntax guard: no time zone, locale, calendar era, or leap second applies.
 *
 * @param value - The unknown value to inspect
 * @returns True if the value is an RFC 3339 `full-date` for a day that exists; false otherwise
@@ -2893,7 +2900,7 @@ function isMCPContent(value) {
 *
 * @remarks
 * The open contract's guard: a record carrying a string `resultType` and, when
-* present, exact result metadata. It deliberately does NOT narrow `resultType` to a
+* present, exact result metadata. It deliberately does not narrow `resultType` to a
 * known value, because the dated schema keeps adding them — a caller that needs a
 * specific result uses that result's own guard, which narrows to its literal.
 * Mutually exclusive with {@link isMCPLegacyResult} on every input: this one needs
@@ -2968,7 +2975,7 @@ function isMCPCallResult(value) {
 * proof: this is what stands between a manager that answers a numeric `taskId` and a
 * client that would receive one. `ttlMs` accepts `null` because the schema uses it to
 * mean "no expiry", which is distinct from an absent field, and both durations must be
-* INTEGER milliseconds because the schema formats them `int`.
+* integer milliseconds because the schema formats them `int`.
 *
 * @param value - The unknown value to inspect
 * @returns True if the value is a well-formed `resultType: 'task'` result; false otherwise
@@ -3019,7 +3026,7 @@ function isMCPTaskStatus(value) {
 * the requests to answer, `completed` owns the deferred call's result, `failed` owns the
 * JSON-RPC error that ended it, and `working` / `cancelled` own nothing further.
 *
-* A `completed` task's `result` is checked as an OBJECT and no further. The schema declares
+* A `completed` task's `result` is checked as an object and no further. The schema declares
 * it an open record, so its contents belong to whichever method was deferred; a guard that
 * demanded a protocol result here would refuse payloads the extension permits.
 * `ttlMs` and `pollIntervalMs` are integer milliseconds, per the schema's `int` formats.
@@ -3061,11 +3068,11 @@ function isMCPTaskDetail(value) {
 * Determines whether a value is the wire answer to `tasks/get`.
 *
 * @remarks
-* {@link isMCPTaskDetail} plus the stamp the METHOD owes. The schema types a `tasks/get`
+* {@link isMCPTaskDetail} plus the stamp the method owes. The schema types a `tasks/get`
 * reply as the detail intersected with the standard result, so `resultType: 'complete'` is
 * part of the answer rather than decoration on it — and an unstamped payload, or one
 * carrying the creation answer's `resultType: 'task'`, is a peer answering some other
-* shape. Use this guard wherever a `tasks/get` REPLY is read; use
+* shape. Use this guard wherever a `tasks/get` reply is read; use
 * {@link isMCPTaskDetail} wherever a consumer's manager answers directly.
 *
 * `_meta` is checked only when present, and only as result metadata: the server identity a
@@ -3095,14 +3102,14 @@ function isMCPTaskDetailResult(value) {
 * Determines whether a value is a `notifications/tasks` frame carrying a task snapshot.
 *
 * @remarks
-* The ADMISSION guard for a task transition: a subscription producer is consumer-written,
+* The admission guard for a task transition: a subscription producer is consumer-written,
 * so the frame it hands over is foreign input, and this is what stands between a mutated
 * or half-built snapshot and a subscribed client. Both halves are checked — the method
 * literal the extension fixes, and params that hold together as an
 * {@link MCPTaskDetail} — because either alone admits a frame the other rejects.
 *
-* `_meta` is checked for SHAPE WHEN PRESENT and nothing more. The reserved subscription
-* stamp is the SERVER'S to write, after this guard admits the frame and the matcher agrees
+* `_meta` is checked for shape when present and nothing more. The reserved subscription
+* stamp is the server's to write, after this guard admits the frame and the matcher agrees
 * to it, so a guard that demanded the stamp would refuse every frame a producer emits.
 *
 * @param value - The unknown value to inspect
@@ -3513,13 +3520,13 @@ function isMCPElicitResult(value) {
 * Determines whether accepted elicitation content satisfies the exact schema that was issued.
 *
 * @remarks
-* {@link isMCPElicitResult} says a response has the SHAPE of a response; this says the
-* response answers the QUESTION that was asked. A server that protects the schema it issued
+* {@link isMCPElicitResult} says a response has the shape of a response; this says the
+* response answers the question that was asked. A server that protects the schema it issued
 * and then never enforces it has bought nothing, so this guard closes that gap: it is what
 * turns a bound schema into a checked one.
 *
 * Every own value must be one {@link MCPElicitValue} — a string, a finite number, a boolean,
-* or an array of strings. A value whose name is DECLARED in `schema.properties` must in
+* or an array of strings. A value whose name is declared in `schema.properties` must in
 * addition satisfy that field's schema: `integer` rejects a fraction, `minimum` / `maximum`
 * bound a number, `minLength` / `maxLength` bound a string by code points, `enum` and `oneOf`
 * bound it to a declared member, `format` is enforced (`uri` by {@link isAbsoluteURI}, `email`
@@ -3528,9 +3535,9 @@ function isMCPElicitResult(value) {
 * `maxItems` with every entry drawn from its `items.enum` or `items.anyOf`. Every name listed
 * in `schema.required` must be present.
 *
-* An UNDECLARED property remains valid: the restricted schema is open by default, so a client
+* An undeclared property remains valid: the restricted schema is open by default, so a client
 * that answers more than it was asked is not refused for it. A `schema` that is not itself a
-* valid {@link MCPElicitSchema} admits NOTHING — an unenforceable schema is never a permissive
+* valid {@link MCPElicitSchema} admits nothing — an unenforceable schema is never a permissive
 * one — which is why `schema` is accepted as `unknown` and checked rather than trusted. Total
 * over hostile content and hostile schemas alike.
 *
@@ -3723,10 +3730,11 @@ function isMCPSampleContent(value) {
 *
 * @remarks
 * The schema's `CreateMessageResult` types `content` as an `anyOf` over one
-* {@link isMCPSampleContent} block or an ARRAY of them, so both are admitted here: a
+* {@link isMCPSampleContent} block or an array of them, so both are admitted here: a
 * tool-using model answers with `tool_use` and `tool_result` blocks, and a model answering in
 * several parts answers with the array. `stopReason` stays an open string because the schema
-* names four values and permits any other a provider reports. Total over hostile input.
+* names `endTurn`, `stopSequence`, `maxTokens`, and `toolUse` and permits any other a provider
+* reports. Total over hostile input.
 *
 * @param value - The unknown value to inspect
 * @returns True if `value` has the sampling-completion shape; false otherwise
@@ -3767,12 +3775,12 @@ function isMCPSampleResult(value) {
 * Determines whether a response answers the exact embedded request that was issued.
 *
 * @remarks
-* A response carries no `method` of its own, so the ISSUED request selects which arm applies
+* A response carries no `method` of its own, so the issued request selects which arm applies
 * — the same way {@link isElicitContent} takes the issued schema rather than trusting the
 * content to describe itself. A form elicitation is checked twice: once for the response
 * shape and once, on `accept`, for the content against the schema that round issued. A
 * URL-mode elicitation issues no schema, so only the shape is checked. A request this
-* package cannot recognize admits NOTHING, because an unrecognized question has no correct
+* package cannot recognize admits nothing, because an unrecognized question has no correct
 * answer. Total over hostile responses and hostile requests alike.
 *
 * @param value - The client's answer to check
@@ -3835,7 +3843,7 @@ function isMCPInputResult(value) {
 *
 * @remarks
 * A request is a record with `jsonrpc === '2.0'`, a string `method`, and an `id`
-* that {@link isJSONRPCId} accepts. An id-less call is NOT a request — it is a
+* that {@link isJSONRPCId} accepts. An id-less call is not a request — it is a
 * {@link JSONRPCNotification}, which {@link isJSONRPCNotification} answers for. The
 * guards are mutually exclusive on every input: this one requires a valid `id`
 * value, that one requires no own `id` member at all. `params`, when present, must
@@ -3864,7 +3872,7 @@ function isJSONRPCRequest(value) {
 * Determines whether a parsed value is a {@link JSONRPCNotification}.
 *
 * @remarks
-* A notification is a request-shaped call carrying NO `id` member — the protocol
+* A notification is a request-shaped call carrying no `id` member — the protocol
 * forbids one, because nothing answers a notification. `params`, when present, must
 * be a record. Total: any other input returns `false`.
 *
@@ -3905,8 +3913,8 @@ function isJSONRPCInvocation(value) {
 * arm of a response.
 *
 * @remarks
-* A result answers a request, so `id` is REQUIRED and must be a valid
-* {@link isJSONRPCId}. The envelope must own a `result` and must NOT own an `error`,
+* A result answers a request, so `id` is required and must be a valid
+* {@link isJSONRPCId}. The envelope must own a `result` and must not own an `error`,
 * which is what makes this guard and {@link isJSONRPCErrorResponse} mutually
 * exclusive on every input. `result` itself must be an object: either a modern
 * {@link isMCPResult} or a legacy {@link isMCPLegacyResult}, never a bare primitive.
@@ -3934,17 +3942,17 @@ function isJSONRPCResultResponse(value) {
 * Determines whether a value is one JSON-RPC `error` member.
 *
 * @remarks
-* The failure OBJECT, not the envelope carrying it — the shape a failed response owns
+* The failure object, not the envelope carrying it — the shape a failed response owns
 * under `error`, and the shape a `failed` {@link MCPTaskDetail} owns under the same name,
 * which is why it is one guard rather than the same checks written twice.
 *
-* It is deliberately STRUCTURAL rather than exact-JSON: `data` is declared `unknown`, so
+* It is deliberately structural rather than exact-JSON: `data` is declared `unknown`, so
 * requiring the whole object to survive a JSON clone would refuse a legal error that
 * carried a non-JSON payload. Both callers here hand it an already-owned value.
 *
 * That choice is why the key reads are guarded. Every sibling guard clones first, and a
 * clone reads each key once behind a boundary that already owns totality; this one is the
-* family's only DIRECT reader, so it meets `code` and `message` exactly as the value defines
+* family's only direct reader, so it meets `code` and `message` exactly as the value defines
 * them — including as accessors that throw. Reading a named key off an unowned value is
 * itself the hostile step, and it is bounded here rather than allowed to escape. Total.
 *
@@ -3967,9 +3975,9 @@ function isJSONRPCError(value) {
 * arm of a response.
 *
 * @remarks
-* `id` is OPTIONAL here and only here: a peer that could not read the failed
-* request's id OMITS the member rather than sending `null`, so an absent `id` is
-* valid and a `null` one is not. The envelope must own an `error` and must NOT own a
+* `id` is optional here and only here: a peer that could not read the failed
+* request's id omits the member rather than sending `null`, so an absent `id` is
+* valid and a `null` one is not. The envelope must own an `error` and must not own a
 * `result`. `error` carries an integer `code` and a string `message`. Total.
 *
 * @param value - The already-parsed value to test
@@ -4059,9 +4067,9 @@ function isModernRequest(value) {
 * Infers the wire era for an MCP protocol revision.
 *
 * @remarks
-* The era is READ from the two era guards rather than restated here, so a revision added
+* The era is read from the era guards rather than restated here, so a revision added
 * to {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS} or {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}
-* carries its era with it and no third list can disagree with those two.
+* carries its era with it and no further list can disagree with them.
 *
 * @param version - The protocol revision to classify
 * @returns `'modern'` for a revision a bare server accepts, `'legacy'` for a revision the
@@ -4075,10 +4083,10 @@ function inferEra(version) {
 * Infers the wire era one invocation's own structure selects.
 *
 * @remarks
-* The STRUCTURAL read, distinct from {@link inferEra}'s read of a revision string: era is fixed
+* The structural read, distinct from {@link inferEra}'s read of a revision string: era is fixed
 * by the reserved modern metadata a request carries, so this answers for a message whose
 * revision has not been read and cannot answer `undefined` — every invocation took one of the
-* two published wire shapes. It is what an observation surface reports and what an ingress
+* published wire shapes. It is what an observation surface reports and what an ingress
 * routes on, so both derive it here rather than each spelling the ternary out.
 *
 * @param invocation - The invocation whose structure selects the era
@@ -4102,15 +4110,15 @@ function inferVersion(offered) {
 	for (const version of SUPPORTED_MODERN_PROTOCOL_VERSIONS) if (offered.includes(version)) return version;
 }
 /**
-* Infers the protocol version an outbound message announces itself with — the ONE
+* Infers the protocol version an outbound message announces itself with — the one
 * projection every HTTP client transport stamps `mcp-protocol-version` from.
 *
 * @remarks
-* This is deliberately the SAME read the server's own expectation performs
+* This is deliberately the same read the server's own expectation performs
 * ({@link import('@orkestrel/mcp/server').inferHeaderIssue}): a modern request's reserved
-* `_meta` version, accepted whenever it is a string. It is NOT
+* `_meta` version, accepted whenever it is a string. It is not
 * {@link import('./parsers.js').parseRequestContext}, and the difference is the whole
-* point. That parser answers a different question — is the modern metadata WELL FORMED —
+* point. That parser answers a different question — is the modern metadata well formed —
 * and refuses a request whose capability declaration or logging level is malformed. Such a
 * request is still modern (era is fixed by key presence) and the server still demands the
 * header for it, so projecting through the parser withholds a header the peer requires and
@@ -4119,7 +4127,7 @@ function inferVersion(offered) {
 * A non-modern message projects nothing: a legacy request's version comes from the
 * `initialize` handshake the transport captured, not from the message.
 *
-* Header NAMES stay with the transports that own the wire (see `constants.ts`); core owns
+* Header names stay with the transports that own the wire (see `constants.ts`); core owns
 * the value this projection derives, which is the part the browser and Node faces disagreed about.
 *
 * @param message - The outbound message about to be written
@@ -4144,10 +4152,10 @@ function inferRequestVersion(message) {
 *
 * @remarks
 * - **One seam.** The server registers its built-in modern methods here at construction
-*   and resolves EVERY modern method from here, so a consumer's method and a built-in
+*   and resolves every modern method from here, so a consumer's method and a built-in
 *   are the same kind of thing on the same path.
 * - **Registration is a write, not a merge.** `add` under a name already present
-*   REPLACES it, which is how a consumer overrides a built-in; there is no precedence
+*   replaces it, which is how a consumer overrides a built-in; there is no precedence
 *   rule to remember.
 * - **A narrower contract than a `Map`.** Callers register and resolve; they cannot
 *   iterate, clear, or otherwise reach the server's internal state through it.
@@ -4300,16 +4308,16 @@ var MCPProgressReporter = class {
 * through.
 *
 * @remarks
-* A native async generator decides cancellation with a QUEUE: `return()` and `throw()` wait
+* A native async generator decides cancellation with a queue: `return()` and `throw()` wait
 * behind a `next()` the producer has not answered, so a consumer abandoning a source parked
 * on an event that will never arrive waits forever for its own cancellation. This class
-* arbitrates instead of queueing. It keeps at most ONE read outstanding against the source,
-* settles the consumer's read itself, aborts the request's lifetime BEFORE it delegates
+* arbitrates instead of queueing. It keeps at most one read outstanding against the source,
+* settles the consumer's read itself, aborts the request's lifetime before it delegates
 * cleanup to the producer — so a cooperating producer is woken rather than waited on —
 * contains every promise the producer settles late, and makes every closure path idempotent.
 *
 * The closures are deliberately different answers: the source's own return is the
-* terminal RESPONSE, `return(value)` is the consumer saying it has the answer already, and
+* terminal response, `return(value)` is the consumer saying it has the answer already, and
 * {@link stop} is an owner saying there will be no answer at all. Only the source's own
 * return is a message a peer ever sees.
 *
@@ -4317,7 +4325,7 @@ var MCPProgressReporter = class {
 * generator is suspended inside, so the signal is how an uncooperative producer is asked to
 * finish, and this controller never blocks its consumer on the answer.
 *
-* **What this class does NOT have is an owner of last resort.** No finalizer, no timer, no
+* **What this class does not have is an owner of last resort.** No finalizer, no timer, no
 * timeout ends an exchange nobody released. That absence is the design: an exchange holds a
 * producer, a request lifetime and a live server slot, so a silent background release would
 * turn "a pump forgot its obligation" from a reproducible defect into a nondeterministic one,
@@ -4498,15 +4506,15 @@ var MCPStreamController = class {
 * serialized.
 *
 * @remarks
-* A TRANSLATION boundary and deliberately nothing else. It serializes each message and the
+* A translation boundary and deliberately nothing else. It serializes each message and the
 * terminating response, and every lifecycle decision — return, throw, dispose, stop — ends
 * the typed exchange beneath it rather than this face. That is the whole design constraint: a
-* serialized face implemented as its own async generator would add a SECOND operation queue,
+* serialized face implemented as its own async generator would add a second operation queue,
 * and the queue is exactly the defect the typed controller exists to remove — a `return()`
 * promptly settled at the text face and left queued at the typed one cancels nothing.
 *
 * One member is a narrowing rather than a pass-through, and it is worth knowing before it
-* surprises a producer. `return` receives a STRING; it cannot rebuild the typed
+* surprises a producer. `return` receives a string; it cannot rebuild the typed
 * `JSONRPCResponse` the typed face would close on, and inventing one by parsing the
 * argument back would make this face decide what the exchange ended with. So it ends the
 * typed exchange with {@link MCPStreamControllerInterface.stop} — no terminal — and answers
@@ -4515,11 +4523,11 @@ var MCPStreamController = class {
 * the honest translation of "the consumer already has its answer" when the answer is opaque
 * text, not a downgrade to work around.
 *
-* It accepts only a CONTROLLED typed stream. A raw generator would have no lifecycle to
+* It accepts only a controlled typed stream. A raw generator would have no lifecycle to
 * delegate to, and this class refuses to grow one of its own.
 *
 * Delegation is total and it is what makes the ownership obligation transitive: `return`,
-* `throw`, `stop`, and dispose each end the TYPED exchange, so a pump holding only this
+* `throw`, `stop`, and dispose each end the typed exchange, so a pump holding only this
 * serialized face still releases the producer, the request lifetime, and the live server slot
 * behind it. There is no owner of last resort here either, for the same reason there is none
 * on the typed face.
@@ -4566,7 +4574,7 @@ var MCPTextStreamController = class {
 	* @remarks
 	* The typed exchange ends with no terminal, because a string is not a
 	* `JSONRPCResponse` and this face never parses one back out of its argument. The
-	* supplied text is the answer to THIS consumer, and a cooperating producer sees its
+	* supplied text is the answer to this consumer, and a cooperating producer sees its
 	* cancellation path rather than its normal return.
 	*
 	* @param value - The serialized terminal the consumer is ending on
@@ -4603,7 +4611,7 @@ var MCPTextStreamController = class {
 	*
 	* @remarks
 	* Delegates downward exactly as {@link stop} does — disposing the serialized arm is
-	* disposing the exchange, never just this adapter.
+	* disposing the exchange, never this adapter alone.
 	*
 	* @returns Resolves once the typed exchange has ended
 	*/
@@ -4659,7 +4667,8 @@ var MCPLegacy = class {
 		const parsed = parseJSON(message);
 		if (isModernRequest(parsed) || !isJSONRPCInvocation(parsed)) return this.#options.dispatcher.handle(message, options);
 		const answer = await this.#legacy(parsed, options);
-		return answer === void 0 ? void 0 : JSON.stringify(answer);
+		if (answer === void 0) return void 0;
+		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
 	}
 	async #legacy(invocation, options) {
 		if (invocation.id === void 0) return void 0;
@@ -4683,13 +4692,42 @@ var MCPLegacy = class {
 	}
 	async #forward(request, options) {
 		const translated = legacyInvocationToModern(request);
-		const answer = await this.#options.dispatcher.dispatch(translated, options);
-		if (Symbol.asyncIterator in answer) {
-			answer.stop();
-			await answer[Symbol.asyncDispose]();
-			return this.#unsupported(request.id, "stream");
+		const metadata = request.method === "tools/call" ? request.params?.["_meta"] : void 0;
+		const candidate = isRecord(metadata) ? metadata["progressToken"] : void 0;
+		const token = isString(candidate) || isInteger(candidate) ? candidate : void 0;
+		if (token === void 0) {
+			const answer = await this.#options.dispatcher.dispatch(translated, options);
+			if (Symbol.asyncIterator in answer) {
+				answer.stop();
+				await answer[Symbol.asyncDispose]();
+				return this.#unsupported(request.id, "stream");
+			}
+			return this.#project(answer, request.id);
+		}
+		const closure = new AbortController();
+		const resolved = buildMethodOptions(options ?? {}, closure.signal);
+		try {
+			const answer = await this.#options.dispatcher.dispatch(translated, resolved);
+			if (Symbol.asyncIterator in answer) return new MCPStreamController(this.#progress(answer, request.id, token), resolved.signal, closure);
+			closure.abort();
+			return this.#project(answer, request.id);
+		} catch (error) {
+			closure.abort(error);
+			throw error;
+		}
+	}
+	async *#progress(stream, id, token) {
+		try {
+			while (true) {
+				const frame = await stream.next();
+				if (frame.done === true) return this.#project(frame.value, id);
+				const params = frame.value.params;
+				if (frame.value.method !== "notifications/progress" || !isRecord(params) || params["progressToken"] !== token || !isMCPProgress(params)) return this.#unsupported(id, "stream");
+				yield frame.value;
+			}
+		} finally {
+			await stream[Symbol.asyncDispose]();
 		}
-		return this.#project(answer, request.id);
 	}
 	#project(answer, id) {
 		if (answer.error !== void 0) return answer.error.code === -32021 ? this.#unsupported(id, this.#capability(answer)) : answer;
@@ -4935,7 +4973,7 @@ var MCPLegacyClientTransport = class {
 //#endregion
 //#region src/core/MCPServer.ts
 /**
-* Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with NO
+* Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with no
 * transport coupling.
 *
 * @remarks
@@ -4945,7 +4983,7 @@ var MCPLegacyClientTransport = class {
 *   `handle(message)` is the string boundary: it
 *   `JSON.parse`s the raw message (a failure → a `-32700` response), narrows it to
 *   an invocation (a non-invocation → a `-32600` response, with the unreadable `id`
-*   OMITTED rather than nulled), dispatches, and serializes the
+*   omitted rather than nulled), dispatches, and serializes the
 *   response back to a string (`undefined` for a notification).
 * - **One modern seam.** `server/discover`, `tools/list`, `tools/call`, and
 *   `subscriptions/listen` are always registered; `resources/*`, `prompts/*`, and
@@ -5636,19 +5674,19 @@ var MCPServer = class {
 //#endregion
 //#region src/core/MCPTaskClient.ts
 /**
-* Issues the `tasks/*` methods over one correlated-request door — the CLIENT half of the
+* Issues the `tasks/*` methods over one correlated-request door — the client half of the
 * stable Tasks extension, exposed as an {@link import('./types.js').MCPClientInterface}'s
 * `tasks`.
 *
 * @remarks
 * - **The mirror of the server-side port, minus `start`.** An
 *   {@link import('./types.js').MCPTaskManagerInterface} is the consumer's durable store the
-*   SERVER creates tasks in; this is the client's read/answer/stop access to the tasks a peer
+*   server creates tasks in; this is the client's read/answer/stop access to the tasks a peer
 *   already created. Creation is missing on purpose: the extension gives a client no flag and
 *   no parameter to ask for a task, so `start` has no wire method to be.
 * - **No plural accessor, no loop, no cache.** MCP defines no `tasks/list`, so nothing here
 *   enumerates. A task snapshot's `pollIntervalMs` is carried untouched and a one-shot read
-*   sits beside it; the SCHEDULE is the consumer's, because this package has no durable place
+*   sits beside it; the schedule is the consumer's, because this package has no durable place
 *   to keep a task, no idea when the application still cares, and no lifetime to hang a timer
 *   on that outlives the request it was born from. An instance left alone writes nothing.
 * - **One channel.** Every request goes through the injected
@@ -5696,20 +5734,20 @@ var MCPTaskClient = class {
 //#endregion
 //#region src/core/MCPClient.ts
 /**
-* Connects to a REMOTE MCP server over any injected {@link MCPMessageTransportInterface},
+* Connects to a remote MCP server over any injected {@link MCPMessageTransportInterface},
 * negotiates the modern revision, and exposes the server's tools as local
 * {@link ToolInterface}s an agent can run.
 *
 * @remarks
-* - **The mirror of `MCPServer`.** The server DISPATCHES requests over a tool registry;
-*   this client ISSUES them over a transport. `connect` probes `server/discover` and exposes
+* - **The mirror of `MCPServer`.** The server dispatches requests over a tool registry;
+*   this client issues them over a transport. `connect` probes `server/discover` and exposes
 *   the negotiated `version`; a legacy peer requires an explicit transport adapter.
 *   `tools()` lists the remote tools and wraps each as a
 *   local {@link ToolInterface} whose `execute` calls back through `call`; `call` runs a
 *   remote `tools/call` and reports the arm the peer answered with — a value, a durable
 *   task, or a request for more input (a remote `isError: true` throws locally, so an
 *   agent's {@link import('@orkestrel/tool').ToolManagerInterface} isolates it into a
-*   `success: false` result just like a local throw). A wrapped tool cannot hand an agent
+*   `success: false` result exactly like a local throw). A wrapped tool cannot hand an agent
 *   a deferred answer, so a non-`'complete'` arm throws there.
 * - **Request↔response correlation.** Each request is tagged with a monotonic numeric
 *   `id` ({@link #nextId}); a single transport `message` subscription resolves / rejects
@@ -5717,9 +5755,9 @@ var MCPTaskClient = class {
 *   every pending request because the peer could not identify which request failed. A
 *   server-initiated message is re-surfaced on the `notification` event, except a progress
 *   frame claimed by the request that asked
-*   for it; a RESPONSE correlating to nothing pending is discarded, because the request it
+*   for it; a response correlating to nothing pending is discarded, because the request it
 *   answers has already settled.
-* - **Per-request cancellation.** `call`'s `options.signal` withdraws ONE caller from ONE
+* - **Per-request cancellation.** `call`'s `options.signal` withdraws one caller from one
 *   request: the pending entry rejects on every carrier, and `notifications/cancelled` goes
 *   out only where the transport declares itself duplex — the dated revision defines no
 *   client-to-server notification over Streamable HTTP, where closing the response stream
@@ -5736,7 +5774,7 @@ var MCPTaskClient = class {
 *   discovery probe uses that same configured deadline, so a silent peer cannot hold
 *   negotiation indefinitely.
 *   `AbortSignal.timeout` (never a raw `setTimeout`) rejects only that pending request, and the
-*   same deadline bounds the WAIT on the transport's `close`, the one wait no drain and no signal
+*   same deadline bounds the wait on the transport's `close`, the one wait no drain and no signal
 *   can reach. It bounds the wait rather than the close, which keeps running, so a retry joins it
 *   instead of shutting one connection down twice.
 * - **Transport-agnostic.** Imports only core siblings (JSON-RPC + the tool vocabulary);
@@ -6270,7 +6308,7 @@ var MCPClient = class {
 //#endregion
 //#region src/core/transports/HTTPClientTransport.ts
 /**
-* Drives a REMOTE Streamable-HTTP MCP server over `fetch` — a CLIENT
+* Drives a remote Streamable-HTTP MCP server over `fetch` — a client
 * {@link MCPMessageTransportInterface} for the Model Context Protocol, the egress mirror of
 * the server's `createMCPRoutes`.
 *
@@ -6282,7 +6320,7 @@ var MCPClient = class {
 *   class, so a reply reaches a page and a Node process through the same decode.
 * - **Request/response over `fetch`.** `send(message)` POSTs the JSON-serialized
 *   message to `options.url` with `content-type: application/json` and an
-*   `Accept` of BOTH `application/json` and `text/event-stream` (so the server may
+*   `Accept` of both `application/json` and `text/event-stream` (so the server may
 *   answer with either framing) — plus any `options.headers` (for example, an `Authorization`
 *   bearer). It then decodes the reply and emits each decoded {@link JSONRPCMessage} on
 *   the `message` event the {@link import('@orkestrel/mcp').MCPClientInterface} subscribes
@@ -6295,12 +6333,12 @@ var MCPClient = class {
 *   Accepted (a notification) carries no body and emits nothing.
 * - **Session and protocol headers.** `start()` is a no-op (a
 *   request/response transport opens no long-lived connection). The
-*   `mcp-session-id` response header, when a STATEFUL server sends one (on
-*   `initialize`), is captured into `session` and then ECHOED as the
-*   `mcp-session-id` request header on every SUBSEQUENT request — so an
+*   `mcp-session-id` response header, when a stateful server sends one (on
+*   `initialize`), is captured into `session` and then echoed as the
+*   `mcp-session-id` request header on every subsequent request — so an
 *   `MCPClient` passes a stateful server's session validation. The
 *   initialize result's `protocolVersion` is likewise captured, but only
-*   when it is a SUPPORTED value, and echoed as `mcp-protocol-version` alone on
+*   when it is a supported value, and echoed as `mcp-protocol-version` alone on
 *   subsequent legacy requests. Modern requests instead derive protocol and method
 *   headers from the message, plus the name header only for `tools/call` — carried in the
 *   protocol's Base64 sentinel form whenever the tool name cannot ride as plain ASCII.
@@ -6308,11 +6346,11 @@ var MCPClient = class {
 *   `close()` clears the captured protocol so a reconnect's `initialize`
 *   POST is headerless; the captured `session` persists across `close()`.
 * - **`close()` releases what is in flight.** Every `fetch` this transport still has open is
-*   ABORTED, which cancels the response body a `send` is reading — an SSE reply the server
+*   aborted, which cancels the response body a `send` is reading — an SSE reply the server
 *   never ends would otherwise outlive the transport, with nothing left able to reach it. The
 *   aborted read surfaces on `error` and the `send` reporting it resolves. `close()` is
 *   idempotent (one `close` event per connected lifetime), and `start()` opens the next one.
-* - **Total at the boundary, and a non-success reply REJECTS.** Every reply is narrowed
+* - **Total at the boundary, and a non-success reply rejects.** Every reply is narrowed
 *   (`parseJSONRPCMessage`, the SSE decoder). A non-message success reply is dropped, never
 *   asserted. A non-success reply that carries no valid JSON-RPC message rejects `send` with
 *   an error naming its HTTP status and body shape — the peer answered, and answering the
@@ -6502,20 +6540,35 @@ var HTTPClientTransport = class {
 *   {@link import('@orkestrel/emitter').EmitterHooks} (see {@link MCPServerOptions})
 * @returns A working {@link MCPServerInterface}
 *
-* @example
+* @example Expose a tool registry over MCP
 * ```ts
 * import { createMCPServer } from '@orkestrel/mcp'
 * import { createTool, createToolManager } from '@orkestrel/tool'
 *
 * const tools = createToolManager()
+* tools.add(
+* 	createTool({
+* 		name: 'search',
+* 		description: 'Search the docs',
+* 		execute: (a) => find(String(a.query)),
+* 	}),
+* )
 * tools.add(createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
 *
-* const server = createMCPServer({ identity: { name: 'calculator', version: '1.0.0' }, tools })
+* const server = createMCPServer({ identity: { name: 'docs', version: '1.0.0' }, tools })
 * server.emitter.on('request', (method, id) => log(method, id))
 *
-* // A transport pumps message strings through `handle`:
-* const reply = await server.handle('{"jsonrpc":"2.0","method":"tools/list","id":1,"params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}')
-* // reply → '{"jsonrpc":"2.0","id":1,"result":{"tools":[{"name":"add","inputSchema":{"type":"object"}}],"resultType":"complete","ttlMs":60000,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"calculator","version":"1.0.0"}}}}'
+* // A transport reads a framed message string and writes the reply:
+* for await (const message of transport) {
+* 	const reply = await server.handle(message)
+* 	if (reply !== undefined) await transport.send(reply) // a notification has no reply
+* }
+*
+* // `handle` also answers one message string on its own:
+* const listed = await server.handle(
+* 	'{"jsonrpc":"2.0","method":"tools/list","id":1,"params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}',
+* )
+* // listed → '{"jsonrpc":"2.0","id":1,"result":{"tools":[{"name":"search","inputSchema":{"type":"object"},"description":"Search the docs"},{"name":"add","inputSchema":{"type":"object"}}],"resultType":"complete","ttlMs":60000,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"docs","version":"1.0.0"}}}}'
 * ```
 */
 function createMCPServer(options) {
@@ -6524,6 +6577,10 @@ function createMCPServer(options) {
 /**
 * Decorates one MCP server with the fixed legacy method translation.
 *
+* @remarks
+* Adds support for the `2025-11-25` and `2025-06-18` legacy revisions. Removing this one
+* decorator removes that legacy surface while leaving the modern dispatcher unchanged.
+*
 * @param server - The sole modern dispatcher and handshake identity source
 * @returns A dispatcher accepting both modern and legacy invocations
 */
@@ -6534,14 +6591,14 @@ function createMCPLegacy(server) {
 	});
 }
 /**
-* Creates a transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE
+* Creates a transport-agnostic Model Context Protocol client — connects to a remote
 * MCP server over an injected {@link import('./types.js').MCPMessageTransportInterface},
 * negotiates the modern revision through `server/discover`, and exposes the server's tools as local
 * {@link import('@orkestrel/tool').ToolInterface}s an agent can run.
 *
 * @remarks
 * The egress mirror of {@link createMCPServer}: where the server exposes a local tool
-* registry over MCP, the client USES a remote server's tools. `connect()` discovers,
+* registry over MCP, the client uses a remote server's tools. `connect()` discovers,
 * validates, and exposes the negotiated modern protocol; a legacy peer requires
 * {@link createMCPLegacyClientTransport}. `tools()` lists + wraps the remote
 * tools (each `execute` calls back over the wire),
@@ -6551,7 +6608,7 @@ function createMCPLegacy(server) {
 * `fetch`) lives in the published server environment; the client itself is provider-agnostic. Subscribe
 * to `connect` / `disconnect` / `notification` through `client.emitter.on(...)`.
 *
-* @param options - `transport` (the carrier; REQUIRED), an optional `identity`
+* @param options - `transport` (the carrier; required), an optional `identity`
 *   (the client identity), `timeout` (the per-request deadline), and the reserved `on`
 *   {@link import('@orkestrel/emitter').EmitterHooks} (see {@link MCPClientOptions})
 * @returns A working {@link MCPClientInterface}
@@ -6597,7 +6654,7 @@ function createMCPLegacyClientTransport(transport, options) {
 * existing shape.
 *
 * @remarks
-* Hand the RESULT to `createMCPClient({ transport })`, then pass the SAME
+* Hand the result to `createMCPClient({ transport })`, then pass the same
 * `transport` to {@link import('./helpers.js').bindClient} to complete the inbound
 * wiring: `send` serializes each outbound {@link JSONRPCMessage} and writes it through
 * `transport.send`; `close` closes the underlying
@@ -6605,10 +6662,10 @@ function createMCPLegacyClientTransport(transport, options) {
 * it is handed in — there is no separate connect step at this layer); `session` is
 * always `undefined` (session correlation is a higher-level concern the duplex port
 * does not carry); and `duplex` is always `true`, because carrying frames in both
-* directions at any moment is exactly what the adapted port is — a claim DRIVEN over a real
+* directions at any moment is exactly what the adapted port is — a claim driven over a real
 * `MessageChannel` and a real scope pair (a client-initiated `notifications/cancelled`
 * observed arriving at the peer) rather than read back off this literal. The literal is
-* true of the PORT, and stays true only while the port has a peer: close the far half and
+* true of the port, and stays true only while the port has a peer: close the far half and
 * this transport still declares `true` while carrying nothing, which is the one thing a
 * per-carrier declaration cannot express. Inbound delivery (`emitter`'s `message` / `close` events) is
 * `bindClient`'s job, not this factory's — the returned object exposes a `message`-