@orkestrel/mcp 0.0.27 → 0.0.29

package/dist/src/core/index.js

@@ -1,10 +1,12 @@
-import { arrayOf, attempt, cloneJSONRecord, cloneJSONValue, isArray, isBoolean, isFiniteNumber, isInteger, isJSONValue, isNumber, isRecord, isString, isUndefined, sanitizeBudget } from "@orkestrel/contract";
+import { arrayOf, attempt, cloneJSONRecord, cloneJSONValue, isArray, isBoolean, isFiniteNumber, isInteger, isJSONValue, isNumber, isRecord, isString, isUndefined, parseJSON, sanitizeBudget } from "@orkestrel/contract";
 import { decodeBase64, decodeUTF8, encodeBase64, encodeHex } from "@orkestrel/codec";
+import { createSSEParser } from "@orkestrel/sse";
 import { Emitter } from "@orkestrel/emitter";
 import { Tool } from "@orkestrel/tool";
 //#region src/core/constants.ts
 /**
-* 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
@@ -12,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";
-/** 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";
-/** 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";
 /**
-* 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
@@ -25,45 +30,51 @@ var MCP_MODERN_VERSION = "2026-07-28";
 * decorator own them.
 */
 var SUPPORTED_MODERN_PROTOCOL_VERSIONS = Object.freeze([MCP_MODERN_VERSION]);
-/** 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]);
-/** The protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy eras. */
+/**
+* Lists the protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy
+* eras.
+*/
 var SUPPORTED_MCP_VERSIONS = Object.freeze([...SUPPORTED_MODERN_PROTOCOL_VERSIONS, ...SUPPORTED_LEGACY_PROTOCOL_VERSIONS]);
-/** Reserved modern `_meta` key carrying the request's protocol revision. */
+/** Names the reserved modern `_meta` key carrying the request's protocol revision. */
 var MCP_META_VERSION = "io.modelcontextprotocol/protocolVersion";
-/** Reserved modern `_meta` key carrying the client's open capability record. */
+/** Names the reserved modern `_meta` key carrying the client's open capability record. */
 var MCP_META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
-/** Reserved modern `_meta` key carrying the optional client identity. */
+/** Names the reserved modern `_meta` key carrying the optional client identity. */
 var MCP_META_CLIENT = "io.modelcontextprotocol/clientInfo";
-/** Reserved modern `_meta` key carrying the server identity on results. */
+/** Names the reserved modern `_meta` key carrying the server identity on results. */
 var MCP_META_SERVER = "io.modelcontextprotocol/serverInfo";
-/** Reserved modern `_meta` key carrying a `subscriptions/listen` request id. */
+/** Names the reserved modern `_meta` key carrying a `subscriptions/listen` request id. */
 var MCP_META_SUBSCRIPTION = "io.modelcontextprotocol/subscriptionId";
 /**
-* The reserved extension key identifying the stable Tasks extension.
+* 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.
 */
 var MCP_EXTENSION_TASKS = "io.modelcontextprotocol/tasks";
 /**
-* The opening marker of the Base64 sentinel a standard MCP header value travels in.
+* 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?";
-/** The closing marker of the Base64 sentinel a standard MCP header value travels in. */
+/** Names the closing marker of the Base64 sentinel a standard MCP header value travels in. */
 var MCP_SENTINEL_SUFFIX = "?=";
 /**
-* The request-header prefix an `x-mcp-header` annotation projects a tool argument onto.
+* Names the request-header prefix an `x-mcp-header` annotation projects a tool argument onto.
 *
 * @remarks
 * The full field name is this prefix followed by the annotation's own value verbatim, so
@@ -73,17 +84,66 @@ var MCP_SENTINEL_SUFFIX = "?=";
 */
 var MCP_PARAM_PREFIX = "Mcp-Param-";
 /**
-* The tool-schema annotation key naming the header one parameter projects into.
+* Names the Streamable-HTTP transport header that carries the MCP session id.
+*
+* @remarks
+* 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.
+*/
+var MCP_SESSION_HEADER = "mcp-session-id";
+/**
+* Names the Streamable-HTTP transport header carrying the MCP protocol version.
+*
+* @remarks
+* A modern request derives it from its own `_meta`; a legacy request echoes the revision the
+* `initialize` result negotiated on each subsequent request.
+*/
+var MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+/**
+* Names the modern Streamable-HTTP request header carrying the JSON-RPC method.
 *
 * @remarks
-* It is valid ONLY on a primitive property schema statically reachable from the `inputSchema`
+* It is stamped on every modern request and on no legacy request.
+*/
+var MCP_METHOD_HEADER = "mcp-method";
+/**
+* Names the modern Streamable-HTTP request header carrying a named target.
+*
+* @remarks
+* The HTTP client transport stamps it only for `tools/call`, from that request's `params.name`,
+* in the Base64 sentinel form whenever the name cannot ride as plain ASCII.
+*/
+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`
 * 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.
 */
 var MCP_HEADER_ANNOTATION = "x-mcp-header";
 /**
-* The `tools/list` pages one modern `tools/call` walks to reach its own annotations.
+* Names the WebSocket subprotocol `createWebSocketClientTransport` requests by default —
+* `'mcp'`, which `createWebSocketServer` selects when the client offers it. Per RFC 6455
+* §4.1 a client MUST fail the connection if the server returns
+* a subprotocol it did not request; Node ≥ 22 (undici) enforces this strictly, so the
+* default bakes the correct value in. Override `WebSocketClientTransportOptions.protocols`
+* only when connecting to a foreign server that speaks a different subprotocol (or `[]`
+* for no subprotocol negotiation at all).
+*
+* @remarks
+* The client sends it in `Sec-WebSocket-Protocol` and the server echoes it in its `101`
+* handshake, so an MCP WebSocket endpoint is distinguishable from any other WebSocket on the
+* same path. The default WebSocket upgrade path is the same `'/mcp'` the HTTP transport mounts
+* at — the upgrade is selected by the `Upgrade: websocket` header, not a separate path.
+*/
+var MCP_WEBSOCKET_SUBPROTOCOL = "mcp";
+/**
+* Bounds the `tools/list` pages one modern `tools/call` walks to reach its own annotations.
 *
 * @remarks
 * The HTTP POST handler reads a called tool's {@link MCP_HEADER_ANNOTATION} annotations by
@@ -97,13 +157,14 @@ var MCP_HEADER_ANNOTATION = "x-mcp-header";
 * answer a name no served definition annotates receives.
 */
 var MCP_LOOKUP_PAGES = 8;
-/** MCP reserved error: required HTTP metadata does not match the request body. */
+/** Names the MCP reserved error for required HTTP metadata that does not match the request body. */
 var MCP_HEADER_MISMATCH = -32020;
 /**
-* MCP reserved error: an operation needs a client capability that was not declared.
+* Names the MCP reserved error for an operation needing a client capability that was not
+* 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
@@ -113,10 +174,10 @@ var MCP_HEADER_MISMATCH = -32020;
 * schema is what a peer implements against.
 */
 var MCP_MISSING_CAPABILITY = -32021;
-/** MCP reserved error: a request names an unsupported protocol revision. */
+/** Names the MCP reserved error for a request naming an unsupported protocol revision. */
 var MCP_UNSUPPORTED_VERSION = -32022;
 /**
-* Default modern result freshness lifetime in milliseconds.
+* Sets the default modern result freshness lifetime in milliseconds.
 *
 * @remarks
 * `ttlMs` is required on cacheable results, while zero means immediately stale
@@ -124,7 +185,8 @@ var MCP_UNSUPPORTED_VERSION = -32022;
 */
 var DEFAULT_MCP_CACHE_TTL = 6e4;
 /**
-* Secure server bounds used when the matching `limit` option leaf is absent or malformed.
+* Sets the secure server bounds used when the matching `limit` option leaf is absent or
+* malformed.
 *
 * @remarks
 * One MiB admits ordinary JSON-RPC requests and substantial tool arguments; 16 KiB admits
@@ -146,10 +208,10 @@ var DEFAULT_MCP_LIMITS = Object.freeze({
 	depth: 32
 });
 /**
-* The one empty argument record every argument-less modern `tools/call` runs with.
+* 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
@@ -160,48 +222,55 @@ var DEFAULT_MCP_LIMITS = Object.freeze({
 * `arguments.constructor` is `undefined` here rather than a function.
 */
 var EMPTY_MCP_ARGUMENTS = Object.freeze(Object.create(null));
-/** JSON-RPC 2.0 reserved error: invalid JSON was received (the message did not parse). */
+/** Names the JSON-RPC 2.0 reserved error for invalid JSON received (the message did not parse). */
 var JSONRPC_PARSE_ERROR = -32700;
-/** JSON-RPC 2.0 reserved error: the payload was not a valid Request object. */
+/** Names the JSON-RPC 2.0 reserved error for a payload that was not a valid Request object. */
 var JSONRPC_INVALID_REQUEST = -32600;
-/** JSON-RPC 2.0 reserved error: the requested method does not exist. */
+/** Names the JSON-RPC 2.0 reserved error for a requested method that does not exist. */
 var JSONRPC_METHOD_NOT_FOUND = -32601;
-/** JSON-RPC 2.0 reserved error: the method's parameters were invalid. */
+/** Names the JSON-RPC 2.0 reserved error for a method's invalid parameters. */
 var JSONRPC_INVALID_PARAMS = -32602;
 /**
-* JSON-RPC 2.0 reserved error: the server failed while handling an otherwise valid request.
+* Names the JSON-RPC 2.0 reserved error for a server that failed while handling an otherwise
+* 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.
 */
 var JSONRPC_INTERNAL_ERROR = -32603;
 /**
-* JSON-RPC 2.0 implementation-defined server error (the `-32000` to `-32099` range).
+* 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.
 */
 var JSONRPC_SERVER_ERROR = -32e3;
-/** The default client name reported in the MCP `initialize` handshake (`clientInfo.name`). */
-var DEFAULT_MCP_CLIENT_NAME = "taverna";
-/** The default client version reported in the MCP `initialize` handshake (`clientInfo.version`). */
+/**
+* Supplies the default client name reported in the MCP `initialize` handshake
+* (`clientInfo.name`).
+*/
+var DEFAULT_MCP_CLIENT_NAME = "@orkestrel/mcp";
+/**
+* Supplies the default client version reported in the MCP `initialize` handshake
+* (`clientInfo.version`).
+*/
 var DEFAULT_MCP_CLIENT_VERSION = "1.0.0";
 /**
-* The default per-request deadline (ms) an `MCPClient` applies when `options.timeout`
+* Sets the default per-request deadline (ms) an `MCPClient` applies when `options.timeout`
 * is unset — a request the remote server does not answer within it rejects.
 */
 var DEFAULT_MCP_REQUEST_TIMEOUT = 3e4;
-/** The default number of subscription frames retained while no client read is parked. */
+/** Sets the default number of subscription frames retained while no client read is parked. */
 var DEFAULT_MCP_SUBSCRIPTION_CAPACITY = 64;
 //#endregion
 //#region src/core/errors.ts
 /**
-* A Model Context Protocol error preserving its machine-readable numeric code and
+* Preserves a Model Context Protocol error's machine-readable numeric code and
 * optional structured context.
 *
 * @remarks
@@ -244,7 +313,7 @@ var MCPError = class extends Error {
 * Determines whether an unknown value is an {@link MCPError}.
 *
 * @param value - The unknown value to inspect
-* @returns `true` only when the value is an `MCPError`
+* @returns True if the value is an `MCPError`; false otherwise
 *
 * @example
 * ```ts
@@ -375,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:
 *
@@ -395,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.
@@ -430,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
@@ -479,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
@@ -497,7 +566,7 @@ function parseRequestContext(value, limits = {
 function parseMCPInputState(value) {
 	try {
 		if (!isString(value)) return void 0;
-		const parsed = JSON.parse(value);
+		const parsed = parseJSON(value);
 		if (!isRecord(parsed)) return void 0;
 		const principal = parsed["principal"];
 		const expiry = parsed["expiry"];
@@ -539,15 +608,15 @@ function parseMCPInputState(value) {
 * does not authorize a form request. Total over hostile input.
 *
 * @param value - The client capability record to inspect
-* @returns `true` when form-mode elicitation is declared
+* @returns True if form-mode elicitation is declared; false otherwise
 *
 * @example
 * ```ts
-* isFormElicitationSupported({ elicitation: {} }) // true — implicit form mode
-* isFormElicitationSupported({ elicitation: { url: {} } }) // false
+* supportsFormElicitation({ elicitation: {} }) // true — implicit form mode
+* supportsFormElicitation({ elicitation: { url: {} } }) // false
 * ```
 */
-function isFormElicitationSupported(value) {
+function supportsFormElicitation(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
 	if (!owned.success) return false;
 	try {
@@ -563,19 +632,19 @@ function isFormElicitationSupported(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
 * `ClientCapabilities` shape the schema defines rather than as a list of names.
 *
 * Each kind maps to one declaration: `sampling/createMessage` to `sampling`, `roots/list` to
-* `roots`, a form elicitation to what {@link isFormElicitationSupported} accepts, and a
+* `roots`, a form elicitation to what {@link supportsFormElicitation} accepts, and a
 * URL-mode elicitation to a record-valued `elicitation.url`. A request this package cannot
 * 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
@@ -611,7 +680,7 @@ function computeMissingCapabilities(requests, capabilities) {
 			if (!isRecord(elicitation) || !isRecord(elicitation["url"])) urlUndeclared = true;
 			continue;
 		}
-		if (!isFormElicitationSupported(declared)) formUndeclared = true;
+		if (!supportsFormElicitation(declared)) formUndeclared = true;
 	}
 	if (formUndeclared && !urlUndeclared) missing["elicitation"] = {};
 	if (urlUndeclared && !formUndeclared) missing["elicitation"] = { url: {} };
@@ -626,28 +695,28 @@ 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.
 *
 * @param value - The client capability record to inspect
-* @returns `true` when the tasks extension is declared as the schema's empty object
+* @returns True if the tasks extension is declared as the schema's empty object; false otherwise
 *
 * @example
 * ```ts
-* isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': {} } }) // true
-* isTaskSupported({ extensions: {} }) // false — the key is the declaration
-* isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': { on: true } } }) // false
+* supportsTask({ extensions: { 'io.modelcontextprotocol/tasks': {} } }) // true
+* supportsTask({ extensions: {} }) // false — the key is the declaration
+* supportsTask({ extensions: { 'io.modelcontextprotocol/tasks': { on: true } } }) // false
 * ```
 */
-function isTaskSupported(value) {
+function supportsTask(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
 	if (!owned.success) return false;
 	try {
@@ -914,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,
@@ -924,7 +993,7 @@ function buildProgressNotification(token, progress) {
 * rather than as a violation.
 *
 * Only write one on a carrier that accepts a client-initiated notification — see
-* {@link import('./types.js').MCPClientTransportInterface.duplex}. On Streamable HTTP the
+* {@link import('./types.js').MCPMessageTransportInterface.duplex}. On Streamable HTTP the
 * dated revision defines no such frame, and closing the response stream is the
 * cancellation signal instead.
 *
@@ -952,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.
@@ -963,7 +1032,7 @@ function buildCancelledNotification(id, reason) {
 *
 * @param method - The method the pending request was issued for
 * @param resultType - The unknown `resultType` the peer answered with
-* @returns Whether that method may legally answer with that `resultType`
+* @returns True if that method may legally answer with that `resultType`; false otherwise
 *
 * @example
 * ```ts
@@ -981,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
@@ -1010,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
@@ -1097,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) {
@@ -1126,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
@@ -1318,7 +1387,7 @@ function buildSubscriptionFilter(requested, supported, enabled = false) {
 *
 * @param notification - The server notification offered by the configured producer
 * @param filter - The filter acknowledged to the client
-* @returns `true` when the notification belongs on this subscription stream
+* @returns True if the notification belongs on this subscription stream; false otherwise
 */
 function matchesSubscriptionNotification(notification, filter) {
 	if (notification.method === "notifications/tools/list_changed") return filter.toolsListChanged === true;
@@ -1383,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
@@ -1439,8 +1508,8 @@ 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
-* `JSON.parse`d at all: a decoder that parses before it measures has already spent the work
+* 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
 * exactly the same thing with each of them: nothing, and let
@@ -1460,8 +1529,129 @@ function buildInitializeResult(name, version, requested) {
 */
 function decodeBoundedMessage(message, limits) {
 	if (!isBoundedString(message, limits.bytes)) return void 0;
-	const parsed = attempt(() => JSON.parse(message));
-	return parsed.success ? parseJSONRPCMessage(parsed.value, limits) : void 0;
+	return parseJSONRPCMessage(parseJSON(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,
+* 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 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.
+*
+* @param emitter - The transport's emitter to deliver onto
+* @param text - One inbound frame's raw text
+* @param fault - The message for the error emitted when the frame parses but is not JSON-RPC
+*
+* @example
+* ```ts
+* deliverMessage(transport.emitter, frame, 'non-JSON-RPC WebSocket frame')
+* ```
+*/
+function deliverMessage(emitter, text, fault) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		emitter.emit("error", error);
+		return;
+	}
+	const message = parseJSONRPCMessage(parsed);
+	if (message === void 0) {
+		emitter.emit("error", new Error(fault));
+		return;
+	}
+	emitter.emit("message", message);
+}
+/**
+* Decodes one SSE event's `data` string into a {@link JSONRPCMessage}, or `undefined`
+* when it is not one — the per-event step {@link readEventStream} folds over.
+*
+* @remarks
+* Parses the `data` (a peer serializes the JSON-RPC envelope as the event's `data`) with
+* `@orkestrel/contract`'s `parseJSON` — the declared JSON boundary, which answers `undefined`
+* instead of throwing — and narrows the parsed value with `parseJSONRPCMessage`. Total:
+* malformed JSON or a non-message value yields `undefined`, never throws.
+*
+* @param data - One SSE event's `data` payload
+* @returns The decoded {@link JSONRPCMessage}, or `undefined`
+*
+* @example
+* ```ts
+* decodeEvent('{"jsonrpc":"2.0","id":1,"result":{}}') // the decoded response
+* ```
+*/
+function decodeEvent(data) {
+	return parseJSONRPCMessage(parseJSON(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.
+*
+* @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
+* 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
+* completion.
+*
+* @param response - The SSE `fetch` Response to decode (its `body` is read to completion)
+* @returns Every {@link JSONRPCMessage} the stream carried, in order
+*
+* @example
+* ```ts
+* const messages = await readEventStream(await fetch(url, { method: 'POST', body }))
+* ```
+*/
+async function readEventStream(response) {
+	const body = response.body;
+	if (body === null) return [];
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const parser = createSSEParser();
+	const messages = [];
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			for (const event of parser.parse(decoder.decode(value, { stream: true }))) {
+				const message = decodeEvent(event.data);
+				if (message !== void 0) messages.push(message);
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return messages;
+}
+/**
+* Builds the error for a non-success HTTP response that carried no JSON-RPC message.
+*
+* @param response - The response whose status is reported
+* @param type - The response's content type, or an empty string when absent
+* @returns An error naming the HTTP status and unsupported response shape
+*
+* @example
+* ```ts
+* const error = buildResponseError(new Response('', { status: 500 }), '')
+* ```
+*/
+function buildResponseError(response, type) {
+	if (type.includes("application/json")) return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained an application/json body that was not a JSON-RPC message`);
+	if (type.includes("text/event-stream")) return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained a text/event-stream body without a JSON-RPC message`);
+	const shape = type === "" ? "a body without a content type" : `an unsupported '${type}' body`;
+	return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained ${shape}`);
 }
 /**
 * Reads the value one standard MCP request header carries, decoding the Base64 sentinel.
@@ -1477,7 +1667,7 @@ function decodeBoundedMessage(message, limits) {
 * 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.
 *
@@ -1523,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
@@ -1563,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`
@@ -1607,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
@@ -1656,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
@@ -1694,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
@@ -1721,7 +1911,7 @@ function renderHeaderValue(value, primitive) {
 *
 * @remarks
 * The projection SEP-2243 requires of an HTTP client, and the same derivation a server runs
-* to know what the request should have carried. Each parameter's value is read at its exact
+* to know what the request must carry. Each parameter's value is read at its exact
 * property path in the call's own `arguments`; an absent or `null` value omits its header
 * entirely, which is the protocol's distinction between "not supplied" and "supplied empty".
 * The rendered text then travels through {@link encodeSentinel}, so a value carrying
@@ -1783,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
@@ -1804,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
@@ -1821,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.
 *
@@ -1856,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
@@ -1945,38 +2135,38 @@ 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.
 *
 * @remarks
 * 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').MCPClientTransportInterface} that itself carries
-* the SAME `transport` (see {@link import('./factories.js').createDuplexClientTransport},
+* with a {@link import('./types.js').MCPMessageTransportInterface} that itself carries
+* 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
@@ -2060,12 +2250,12 @@ 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
-* @returns `true` when the value is exact metadata whose subscription stamp, if present, is valid
+* @returns True if the value is exact metadata whose subscription stamp, if present, is valid; false otherwise
 *
 * @example
 * ```ts
@@ -2088,7 +2278,7 @@ function isMCPLoggingLevel(value) {
 * Determines whether a value is standard padded base64 as required by JSON Schema `byte` format.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an empty or completely padded standard base64 encoding
+* @returns True if the value is an empty or completely padded standard base64 encoding; false otherwise
 */
 function isStandardBase64(value) {
 	return isString(value) && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
@@ -2104,7 +2294,7 @@ function isStandardBase64(value) {
 * {@link MCP_PARAM_PREFIX} and must survive as an HTTP field name.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a non-empty RFC 9110 token
+* @returns True if the value is a non-empty RFC 9110 token; false otherwise
 *
 * @example
 * ```ts
@@ -2124,7 +2314,7 @@ function isFieldToken(value) {
 * exactly, and the server compares it numerically.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is one of `'string'`, `'integer'`, or `'boolean'`
+* @returns True if the value is one of `'string'`, `'integer'`, or `'boolean'`; false otherwise
 *
 * @example
 * ```ts
@@ -2143,7 +2333,7 @@ function isMCPHeaderPrimitive(value) {
 * scheme allowlist. Component scanning is bounded by the input length.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an RFC 3986 URI rather than a relative reference
+* @returns True if the value is an RFC 3986 URI rather than a relative reference; false otherwise
 */
 function isAbsoluteURI(value) {
 	if (!isString(value) || value.length === 0) return false;
@@ -2228,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
@@ -2236,10 +2426,10 @@ 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 Whether the value is an RFC 3339 `full-date` for a day that exists
+* @returns True if the value is an RFC 3339 `full-date` for a day that exists; false otherwise
 *
 * @example
 * ```ts
@@ -2272,7 +2462,7 @@ function isRFC3339Date(value) {
 * second.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an RFC 3339 `date-time` for a day that exists
+* @returns True if the value is an RFC 3339 `date-time` for a day that exists; false otherwise
 *
 * @example
 * ```ts
@@ -2290,7 +2480,7 @@ function isRFC3339DateTime(value) {
 * Determines whether a value is one exact finite MCP progress payload.
 *
 * @param value - The unknown value to inspect
-* @returns Whether required progress and optional total/message fields match the dated schema
+* @returns True if required progress and optional total/message fields match the dated schema; false otherwise
 */
 function isMCPProgress(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2309,7 +2499,7 @@ function isMCPProgress(value) {
 * Determines whether a value carries valid dated-schema MCP content annotations.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is valid MCP annotations
+* @returns True if the value is valid MCP annotations; false otherwise
 */
 function isMCPAnnotations(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2330,7 +2520,7 @@ function isMCPAnnotations(value) {
 * Determines whether a value is one exact dated-schema MCP icon.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid MCP icon
+* @returns True if the value is a valid MCP icon; false otherwise
 */
 function isMCPIcon(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2421,7 +2611,7 @@ function isMCPServerCapabilities(value) {
 * Determines whether a value is embedded textual MCP resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is embedded textual resource contents
+* @returns True if the value is embedded textual resource contents; false otherwise
 */
 function isMCPTextResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2440,7 +2630,7 @@ function isMCPTextResource(value) {
 * Determines whether a value is embedded blob MCP resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is embedded blob resource contents
+* @returns True if the value is embedded blob resource contents; false otherwise
 */
 function isMCPBlobResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2459,7 +2649,7 @@ function isMCPBlobResource(value) {
 * Determines whether a value is one `resources/list` descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid resource descriptor
+* @returns True if the value is a valid resource descriptor; false otherwise
 */
 function isMCPResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2481,7 +2671,7 @@ function isMCPResource(value) {
 * level belong to the consumer-supplied resource manager; this package projects the string.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid resource-template descriptor
+* @returns True if the value is a valid resource-template descriptor; false otherwise
 */
 function isMCPResourceTemplate(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2498,7 +2688,7 @@ function isMCPResourceTemplate(value) {
 * Determines whether a value is structurally discriminated resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether exactly one of `text` and `blob` is present and valid
+* @returns True if exactly one of `text` and `blob` is present and valid; false otherwise
 */
 function isMCPResourceContents(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2512,7 +2702,7 @@ function isMCPResourceContents(value) {
 * Determines whether a value carries the shared optional pagination cursor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether a present `cursor` is a string
+* @returns True if a present `cursor` is a string; false otherwise
 */
 function isMCPPaginationParams(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2522,7 +2712,7 @@ function isMCPPaginationParams(value) {
 * Determines whether a value is one consumer-owned resource page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the resources and optional following cursor are valid
+* @returns True if the resources and optional following cursor are valid; false otherwise
 */
 function isMCPResourcePage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2535,7 +2725,7 @@ function isMCPResourcePage(value) {
 * Determines whether a value is one consumer-owned resource-template page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the templates and optional following cursor are valid
+* @returns True if the templates and optional following cursor are valid; false otherwise
 */
 function isMCPResourceTemplatePage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2548,7 +2738,7 @@ function isMCPResourceTemplatePage(value) {
 * Determines whether a value is a string-valued MCP argument record.
 *
 * @param value - The unknown value to inspect
-* @returns Whether every own argument value is a string
+* @returns True if every own argument value is a string; false otherwise
 */
 function isMCPStringArguments(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2558,7 +2748,7 @@ function isMCPStringArguments(value) {
 * Determines whether a value is one prompt argument descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt argument descriptor is valid
+* @returns True if the prompt argument descriptor is valid; false otherwise
 */
 function isMCPPromptArgument(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2570,7 +2760,7 @@ function isMCPPromptArgument(value) {
 * Determines whether a value is one `prompts/list` descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt descriptor is valid
+* @returns True if the prompt descriptor is valid; false otherwise
 */
 function isMCPPrompt(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2584,7 +2774,7 @@ function isMCPPrompt(value) {
 * Determines whether a value is one prompt message with existing rich content.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the role and content are valid
+* @returns True if the role and content are valid; false otherwise
 */
 function isMCPPromptMessage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2594,7 +2784,7 @@ function isMCPPromptMessage(value) {
 * Determines whether a value is one consumer-owned prompt page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompts and optional following cursor are valid
+* @returns True if the prompts and optional following cursor are valid; false otherwise
 */
 function isMCPPromptPage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2607,7 +2797,7 @@ function isMCPPromptPage(value) {
 * Determines whether a value is one complete `prompts/get` result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt result and all messages are valid
+* @returns True if the prompt result and all messages are valid; false otherwise
 */
 function isMCPPromptGetResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2620,7 +2810,7 @@ function isMCPPromptGetResult(value) {
 * Determines whether a value is a prompt or resource-template completion reference.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the discriminated reference is valid
+* @returns True if the discriminated reference is valid; false otherwise
 */
 function isMCPCompletionReference(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2632,7 +2822,7 @@ function isMCPCompletionReference(value) {
 * Determines whether a value is one `completion/complete` parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns Whether its reference, fragment, and optional string context are valid
+* @returns True if its reference, fragment, and optional string context are valid; false otherwise
 */
 function isMCPCompletionParams(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2651,7 +2841,7 @@ function isMCPCompletionParams(value) {
 * Determines whether a value is one host-produced completion candidate set.
 *
 * @param value - The unknown value to inspect
-* @returns Whether its candidates and optional result facts are valid
+* @returns True if its candidates and optional result facts are valid; false otherwise
 */
 function isMCPCompletion(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2665,7 +2855,7 @@ function isMCPCompletion(value) {
 * Determines whether a value is one complete, capped `completion/complete` result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the result is complete and carries at most 100 candidates
+* @returns True if the result is complete and carries at most 100 candidates; false otherwise
 */
 function isMCPCompletionResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2677,7 +2867,7 @@ function isMCPCompletionResult(value) {
 * Determines whether a value is one exact dated-schema MCP tool content block.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is valid MCP content
+* @returns True if the value is valid MCP content; false otherwise
 */
 function isMCPContent(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2710,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
@@ -2718,7 +2908,7 @@ function isMCPContent(value) {
 * input.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a modern result
+* @returns True if the value is a modern result; false otherwise
 *
 * @example
 * ```ts
@@ -2744,7 +2934,7 @@ function isMCPResult(value) {
 * hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a legacy result
+* @returns True if the value is a legacy result; false otherwise
 *
 * @example
 * ```ts
@@ -2760,7 +2950,7 @@ function isMCPLegacyResult(value) {
 * Determines whether a value is a complete modern MCP tool result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a complete MCP call result
+* @returns True if the value is a complete MCP call result; false otherwise
 */
 function isMCPCallResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2785,10 +2975,10 @@ 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 Whether the value is a well-formed `resultType: 'task'` result
+* @returns True if the value is a well-formed `resultType: 'task'` result; false otherwise
 *
 * @example
 * ```ts
@@ -2815,7 +3005,7 @@ function isMCPTaskResult(value) {
 * Determines whether a value is one of the extension's task lifecycle states.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an {@link MCPTaskStatus}
+* @returns True if the value is an {@link MCPTaskStatus}; false otherwise
 *
 * @example
 * ```ts
@@ -2836,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.
@@ -2846,7 +3036,7 @@ function isMCPTaskStatus(value) {
 * What is checked is what this package publishes as the contract.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed {@link MCPTaskDetail}
+* @returns True if the value is a well-formed {@link MCPTaskDetail}; false otherwise
 *
 * @example
 * ```ts
@@ -2878,18 +3068,18 @@ 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
 * peer stamps there is the peer's to write.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed {@link MCPTaskDetailResult}
+* @returns True if the value is a well-formed {@link MCPTaskDetailResult}; false otherwise
 *
 * @example
 * ```ts
@@ -2912,18 +3102,18 @@ 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
-* @returns Whether the value is a well-formed `notifications/tasks` notification
+* @returns True if the value is a well-formed `notifications/tasks` notification; false otherwise
 *
 * @example
 * ```ts
@@ -2951,7 +3141,7 @@ function isMCPTaskNotification(value) {
 *
 * @param value - The unknown value to inspect
 * @param bytes - The maximum accepted encoded bytes
-* @returns `true` only for a string whose UTF-8 representation fits the bound
+* @returns True if `value` is a string whose UTF-8 representation fits the bound; false otherwise
 *
 * @example
 * ```ts
@@ -2987,7 +3177,7 @@ function isBoundedString(value, bytes) {
 *
 * @param value - The unknown value to inspect
 * @param limits - Serialized byte, optional key, and nesting-depth bounds
-* @returns `true` only for safe JSON satisfying every bound
+* @returns True if `value` is safe JSON satisfying every bound; false otherwise
 *
 * @example
 * ```ts
@@ -3009,7 +3199,7 @@ function isBoundedJSON(value, limits) {
 * no minimum length. Total: any other input returns `false`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a string or a finite integer
+* @returns True if `value` is a string or a finite integer; false otherwise
 *
 * @example
 * ```ts
@@ -3027,7 +3217,7 @@ function isJSONRPCId(value) {
 * Determines whether a value is a supported {@link MCPVersion}.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_MCP_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_MCP_VERSIONS}; false otherwise
 */
 function isMCPVersion(value) {
 	return isString(value) && SUPPORTED_MCP_VERSIONS.some((version) => version === value);
@@ -3036,7 +3226,7 @@ function isMCPVersion(value) {
 * Determines whether a value is a modern protocol revision accepted by a bare server.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS}; false otherwise
 */
 function isMCPModernVersion(value) {
 	return isString(value) && SUPPORTED_MODERN_PROTOCOL_VERSIONS.some((version) => version === value);
@@ -3045,7 +3235,7 @@ function isMCPModernVersion(value) {
 * Determines whether a value is a revision accepted by the optional legacy decorator.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}; false otherwise
 */
 function isMCPLegacyVersion(value) {
 	return isString(value) && SUPPORTED_LEGACY_PROTOCOL_VERSIONS.some((version) => version === value);
@@ -3064,7 +3254,7 @@ function isMCPLegacyVersion(value) {
 * the caller asked for.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when every recognized filter field has its protocol shape
+* @returns True if every recognized filter field has its protocol shape; false otherwise
 */
 function isMCPSubscriptionFilter(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -3085,7 +3275,7 @@ function isMCPSubscriptionFilter(value) {
 * Determines whether a value is a graceful `subscriptions/listen` result.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the result is complete and carries a valid subscription id
+* @returns True if the result is complete and carries a valid subscription id; false otherwise
 */
 function isMCPSubscriptionResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -3097,7 +3287,7 @@ function isMCPSubscriptionResult(value) {
 * Determines whether a value is one restricted primitive form-elicitation schema.
 *
 * @param value - The unknown value to inspect
-* @returns `true` for a supported boolean, numeric, string, or string-array schema
+* @returns True if `value` is a supported boolean, numeric, string, or string-array schema; false otherwise
 *
 * @example
 * ```ts
@@ -3160,7 +3350,7 @@ function isMCPElicitFieldSchema(value) {
 * an unrecognized top-level annotation is data rather than a rejection.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a restricted object schema of supported field schemas
+* @returns True if `value` is a restricted object schema of supported field schemas; false otherwise
 *
 * @example
 * ```ts
@@ -3187,7 +3377,7 @@ function isMCPElicitSchema(value) {
 * Determines whether a value is a form-mode elicitation parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` has the restricted form elicitation shape
+* @returns True if `value` has the restricted form elicitation shape; false otherwise
 *
 * @example
 * ```ts
@@ -3213,7 +3403,7 @@ function isMCPElicitForm(value) {
 * Determines whether a value is a URL-mode elicitation parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` has the URL elicitation shape
+* @returns True if `value` has the URL elicitation shape; false otherwise
 *
 * @example
 * ```ts
@@ -3234,7 +3424,7 @@ function isMCPElicitURL(value) {
 * Determines whether a value is an embedded `elicitation/create` request.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a form- or URL-mode elicitation request
+* @returns True if `value` is a form- or URL-mode elicitation request; false otherwise
 *
 * @example
 * ```ts
@@ -3259,7 +3449,7 @@ function isMCPElicitRequest(value) {
 * Determines whether a value is one legal embedded multi-round-trip request.
 *
 * @param value - The unknown value to inspect
-* @returns `true` for an embedded elicitation, sampling, or roots request
+* @returns True if `value` is an embedded elicitation, sampling, or roots request; false otherwise
 *
 * @example
 * ```ts
@@ -3283,7 +3473,7 @@ function isMCPInputRequest(value) {
 * Determines whether a value is a consumer-keyed map of embedded input requests.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when every own value is a legal {@link MCPInputRequest}
+* @returns True if every own value is a legal {@link MCPInputRequest}; false otherwise
 *
 * @example
 * ```ts
@@ -3303,7 +3493,7 @@ function isMCPInputRequestMap(value) {
 * Determines whether a value is one elicitation response.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when action/content have the protocol shape
+* @returns True if action/content have the protocol shape; false otherwise
 *
 * @example
 * ```ts
@@ -3330,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`
@@ -3345,15 +3535,15 @@ 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.
 *
 * @param value - The accepted response content to check
 * @param schema - The exact {@link MCPElicitSchema} that was issued with the elicitation
-* @returns `true` when every declared and undeclared value is legal under `schema`
+* @returns True if every declared and undeclared value is legal under `schema`; false otherwise
 *
 * @example
 * ```ts
@@ -3442,7 +3632,7 @@ function isElicitContent(value, schema) {
 * including a URL-mode elicitation's `url`. Total over hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` carries an absolute `uri` and an optional string `name`
+* @returns True if `value` carries an absolute `uri` and an optional string `name`; false otherwise
 *
 * @example
 * ```ts
@@ -3472,7 +3662,7 @@ function isMCPRoot(value) {
 * {@link isMCPRoot}. Total over hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` carries an array of valid roots
+* @returns True if `value` carries an array of valid roots; false otherwise
 *
 * @example
 * ```ts
@@ -3505,7 +3695,7 @@ function isMCPRootResult(value) {
 * input.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is one legal sampling content block
+* @returns True if `value` is one legal sampling content block; false otherwise
 *
 * @example
 * ```ts
@@ -3540,13 +3730,14 @@ 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` when `value` has the sampling-completion shape
+* @returns True if `value` has the sampling-completion shape; false otherwise
 *
 * @example
 * ```ts
@@ -3584,17 +3775,17 @@ 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
 * @param request - The exact {@link MCPInputRequest} that was issued under the same key
-* @returns `true` when the answer is legal for that request
+* @returns True if the answer is legal for that request; false otherwise
 *
 * @example
 * ```ts
@@ -3622,7 +3813,7 @@ function isMCPInputResponse(value, request) {
 * both must be present and valid. Total over hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a valid input-required result
+* @returns True if `value` is a valid input-required result; false otherwise
 *
 * @example
 * ```ts
@@ -3652,14 +3843,14 @@ 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
 * be a record. Total: any other input returns `false`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC request
+* @returns True if `value` is a valid JSON-RPC request; false otherwise
 *
 * @example
 * ```ts
@@ -3681,12 +3872,12 @@ 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`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC notification
+* @returns True if `value` is a valid JSON-RPC notification; false otherwise
 *
 * @example
 * ```ts
@@ -3712,7 +3903,7 @@ function isJSONRPCNotification(value) {
 * mutually exclusive, so a positive answer names exactly one arm. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC request or notification
+* @returns True if `value` is a valid JSON-RPC request or notification; false otherwise
 */
 function isJSONRPCInvocation(value) {
 	return isJSONRPCRequest(value) || isJSONRPCNotification(value);
@@ -3722,15 +3913,15 @@ 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.
 * Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC result response
+* @returns True if `value` is a valid JSON-RPC result response; false otherwise
 *
 * @example
 * ```ts
@@ -3751,22 +3942,22 @@ 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.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` carries an integer `code` and a string `message`
+* @returns True if `value` carries an integer `code` and a string `message`; false otherwise
 *
 * @example
 * ```ts
@@ -3784,13 +3975,13 @@ 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
-* @returns `true` when `value` is a valid JSON-RPC error response
+* @returns True if `value` is a valid JSON-RPC error response; false otherwise
 *
 * @example
 * ```ts
@@ -3814,7 +4005,7 @@ function isJSONRPCErrorResponse(value) {
 * The union of the mutually exclusive arms. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC response
+* @returns True if `value` is a valid JSON-RPC response; false otherwise
 */
 function isJSONRPCResponse(value) {
 	return isJSONRPCResultResponse(value) || isJSONRPCErrorResponse(value);
@@ -3827,7 +4018,7 @@ function isJSONRPCResponse(value) {
 * The union of {@link isJSONRPCInvocation} and {@link isJSONRPCResponse}. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC message
+* @returns True if `value` is a valid JSON-RPC message; false otherwise
 */
 function isJSONRPCMessage(value) {
 	return isJSONRPCInvocation(value) || isJSONRPCResponse(value);
@@ -3836,7 +4027,7 @@ function isJSONRPCMessage(value) {
 * Determines whether a parsed value is an MCP `initialize` invocation.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid `initialize` request or notification
+* @returns True if `value` is a valid `initialize` request or notification; false otherwise
 *
 * @example
 * ```ts
@@ -3859,7 +4050,7 @@ function isInitializeRequest(value) {
 * legacy dispatch. Total over hostile and malformed input.
 *
 * @param value - The already-parsed value to inspect
-* @returns `true` when the value is an invocation carrying the reserved version key
+* @returns True if the value is an invocation carrying the reserved version key; false otherwise
 */
 function isModernRequest(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -3876,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
@@ -3889,6 +4080,27 @@ function inferEra(version) {
 	if (isMCPLegacyVersion(version)) return "legacy";
 }
 /**
+* 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
+* 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
+* 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
+* @returns `'modern'` when the invocation carries the modern request shape, `'legacy'` otherwise
+*
+* @example
+* ```ts
+* inferRequestEra({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } })
+* ```
+*/
+function inferRequestEra(invocation) {
+	return isModernRequest(invocation) ? "modern" : "legacy";
+}
+/**
 * Infers the newest supported modern protocol revision present in a peer's offer.
 *
 * @param offered - The protocol revisions offered by the peer
@@ -3898,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
@@ -3915,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
@@ -3934,16 +4146,16 @@ function inferRequestVersion(message) {
 //#endregion
 //#region src/core/MCPMethodManager.ts
 /**
-* The modern method registry an {@link import('./types.js').MCPServerInterface}
+* Holds the modern methods an {@link import('./types.js').MCPServerInterface}
 * dispatches through — a name-keyed store of {@link MCPMethodHandler}s that owns its
 * map rather than exposing one.
 *
 * @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.
@@ -3968,7 +4180,7 @@ var MCPMethodManager = class {
 //#endregion
 //#region src/core/MCPProgressReporter.ts
 /**
-* A bounded, request-scoped progress handoff between one producer and one serial consumer.
+* Hands bounded, request-scoped progress from one producer to one serial consumer.
 *
 * The reporter holds at most one owned progress item. {@link report} applies backpressure until
 * {@link take} consumes that slot. It has no replay, queue, concurrent-consumer coordination,
@@ -4092,19 +4304,20 @@ var MCPProgressReporter = class {
 //#endregion
 //#region src/core/MCPStreamController.ts
 /**
-* The one cancellation engine every modern held-open result leaves `MCPServer` through.
+* Provides the one cancellation engine every modern held-open result leaves `MCPServer`
+* 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.
 *
@@ -4112,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,
@@ -4289,19 +4502,19 @@ var MCPStreamController = class {
 //#endregion
 //#region src/core/MCPTextStreamController.ts
 /**
-* The string-boundary mirror of a controlled held-open result — the same exchange, already
+* Mirrors a controlled held-open result at the string boundary — the same exchange, already
 * 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
@@ -4310,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.
@@ -4361,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
@@ -4398,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
 	*/
@@ -4451,15 +4664,11 @@ var MCPLegacy = class {
 	}
 	async handle(message, options) {
 		if (!isBoundedString(message, this.limit.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
-		let parsed;
-		try {
-			parsed = JSON.parse(message);
-		} catch {
-			return this.#options.dispatcher.handle(message, options);
-		}
+		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;
@@ -4483,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;
@@ -4543,7 +4781,7 @@ var MCPLegacyClientTransport = class {
 		if (requested !== void 0 && !isMCPLegacyVersion(requested)) throw new MCPError("Unsupported legacy protocol version", MCP_UNSUPPORTED_VERSION, { requested });
 		this.#transport = transport;
 		this.#client = options?.identity ?? {
-			name: "taverna",
+			name: "@orkestrel/mcp",
 			version: "1.0.0"
 		};
 		this.#capabilities = options?.capabilities ?? {};
@@ -4735,8 +4973,8 @@ var MCPLegacyClientTransport = class {
 //#endregion
 //#region src/core/MCPServer.ts
 /**
-* A transport-agnostic Model Context Protocol server — dispatches JSON-RPC 2.0
-* requests over a live {@link ToolManagerInterface}, with NO transport coupling.
+* Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with no
+* transport coupling.
 *
 * @remarks
 * - **`dispatch` and `handle`.** `dispatch(invocation)` runs an already-parsed invocation and
@@ -4745,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
@@ -4813,8 +5051,21 @@ var MCPServer = class {
 		if (decoded === void 0 || !("method" in decoded)) return buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request");
 		return this.#dispatch(decoded, options);
 	}
+	async handle(message, options) {
+		if (!isBoundedString(message, this.#limits.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
+		const parsed = parseJSON(message);
+		if (parsed === void 0) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
+		const decoded = parseJSONRPCMessage(parsed, {
+			bytes: this.#limits.message,
+			depth: this.#limits.depth
+		});
+		if (decoded === void 0 || !("method" in decoded)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
+		const answer = await this.#dispatch(decoded, options ?? {});
+		if (answer === void 0) return void 0;
+		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
+	}
 	async #dispatch(invocation, options) {
-		this.#emitter.emit("request", invocation.method, invocation.id, "modern");
+		this.#emitter.emit("request", invocation.method, invocation.id, inferRequestEra(invocation));
 		if (invocation.id === void 0) return;
 		const id = invocation.id;
 		const metadata = invocation.params?.["_meta"];
@@ -4832,26 +5083,9 @@ var MCPServer = class {
 			return this.#contain(error, id);
 		}
 	}
-	async handle(message, options) {
-		if (!isBoundedString(message, this.#limits.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
-		let parsed;
-		try {
-			parsed = JSON.parse(message);
-		} catch {
-			return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
-		}
-		const decoded = parseJSONRPCMessage(parsed, {
-			bytes: this.#limits.message,
-			depth: this.#limits.depth
-		});
-		if (decoded === void 0 || !("method" in decoded)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
-		const answer = await this.#dispatch(decoded, options ?? {});
-		if (answer === void 0) return void 0;
-		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
-	}
 	#register() {
-		this.#methods.add("server/discover", async (request, _options) => this.#discover(request));
-		this.#methods.add("tools/list", async (request, _options) => this.#list(request));
+		this.#methods.add("server/discover", async (request) => this.#discover(request));
+		this.#methods.add("tools/list", async (request) => this.#list(request));
 		this.#methods.add("tools/call", async (request, options) => this.#call(request, options));
 		this.#methods.add("subscriptions/listen", async (request, options) => this.#subscribe(request, options));
 		const resources = this.#options.resources;
@@ -5065,20 +5299,20 @@ var MCPServer = class {
 	async #defer(request, call, options) {
 		const configured = this.#options.task;
 		if (configured === void 0) return void 0;
-		const deferral = {
+		const deferred = {
 			request,
 			call,
 			tools: this.#options.tools
 		};
-		const key = await configured.defer(deferral, options);
+		const key = await configured.deferral(deferred, options);
 		if (isUndefined(key)) return void 0;
 		if (!isString(key) || key.length === 0) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server execution returned an invalid task key");
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (context === void 0 || !isTaskSupported(context.capabilities)) return buildJSONRPCError(request.id, MCP_MISSING_CAPABILITY, "Client does not support the required Tasks extension", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
-		const created = await configured.tasks.start(key, deferral, options);
+		if (context === void 0 || !supportsTask(context.capabilities)) return buildJSONRPCError(request.id, MCP_MISSING_CAPABILITY, "Client does not support the required Tasks extension", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
+		const created = await configured.tasks.start(key, deferred, options);
 		const captured = snapshotJSON({
 			resultType: "task",
 			taskId: created.taskId,
@@ -5162,7 +5396,7 @@ var MCPServer = class {
 			arguments: args
 		}, options);
 		if (selected === void 0) return void 0;
-		const round = this.#round(selected);
+		const round = this.#ownRound(selected);
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
@@ -5215,7 +5449,7 @@ var MCPServer = class {
 		const state = parseMCPInputState(verified);
 		if (state === void 0) return this.#contain(/* @__PURE__ */ new Error("Continuation port opened a malformed protected payload"), id);
 		if (state.expiry <= Date.now() || state.id === id || state.version !== context.version || state.method !== request.method || state.name !== name || state.digest !== digest) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
-		const responses = this.#answers(state.requests, inputResponses);
+		const responses = this.#checkAnswers(state.requests, inputResponses);
 		if (responses === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: an input response is missing or malformed");
 		const principal = await configured.principal(request, options);
 		if (!isString(principal) || principal.length === 0 || state.principal !== principal) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
@@ -5228,13 +5462,13 @@ var MCPServer = class {
 		}, options);
 		if (state.expiry <= Date.now()) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
 		if (selected === void 0) return void 0;
-		const round = this.#round(selected);
+		const round = this.#ownRound(selected);
 		if (round === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: input policy returned an invalid round or continuation context");
 		const refusal = this.#gate(round, context, id);
 		if (refusal !== void 0) return refusal;
 		return this.#required(request, name, digest, round, principal, state.id, state.expiry);
 	}
-	#answers(requests, responses) {
+	#checkAnswers(requests, responses) {
 		const answered = {};
 		for (const [key, issued] of Object.entries(requests)) {
 			const response = responses[key];
@@ -5243,7 +5477,7 @@ var MCPServer = class {
 		}
 		return Object.freeze(answered);
 	}
-	#round(round) {
+	#ownRound(round) {
 		const owned = snapshotJSON(round, {
 			bytes: this.#limits.content,
 			keys: this.#limits.keys,
@@ -5331,7 +5565,7 @@ var MCPServer = class {
 			}
 			yield buildSubscriptionAcknowledgement(notifications, id);
 			if (configured !== void 0) {
-				const iterator = (await configured.listen(notifications, options))[Symbol.asyncIterator]();
+				const iterator = (await configured.producer(notifications, options))[Symbol.asyncIterator]();
 				options.signal.addEventListener("abort", () => void iterator.return?.(void 0)?.catch(() => void 0), { once: true });
 				for (let next = await iterator.next(); next.done !== true; next = await iterator.next()) {
 					const owned = parseJSONRPCMessage(next.value, {
@@ -5350,22 +5584,22 @@ var MCPServer = class {
 			slot.abort();
 		}
 	}
-	#named(request) {
+	#readTaskId(request) {
 		const id = request.id;
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (context === void 0 || !isTaskSupported(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the tasks extension capability for this request", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
+		if (context === void 0 || !supportsTask(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the tasks extension capability for this request", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
 		const taskId = request.params?.["taskId"];
 		if (!isBoundedString(taskId, this.#limits.state) || taskId.length === 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: a bounded string `taskId` is required");
 		return taskId;
 	}
 	async #task(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
-		const found = await tasks.task(named, options);
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
+		const found = await tasks.task(taskId, options);
 		if (found === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
 		const owned = snapshotJSON(found, {
 			bytes: this.#limits.content,
@@ -5377,20 +5611,20 @@ var MCPServer = class {
 	}
 	async #update(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
 		const responses = request.params?.["inputResponses"];
 		if (!isRecord(responses)) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: an `inputResponses` object is required");
-		if (!isMCPTaskDetail(await tasks.task(named, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
-		await tasks.update(named, responses, options);
+		if (!isMCPTaskDetail(await tasks.task(taskId, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
+		await tasks.update(taskId, responses, options);
 		return buildJSONRPCResult(id, buildModernResult({}, this.#options.identity));
 	}
 	async #abort(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
-		if (!isMCPTaskDetail(await tasks.task(named, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
-		await tasks.abort(named, options);
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
+		if (!isMCPTaskDetail(await tasks.task(taskId, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
+		await tasks.abort(taskId, options);
 		return buildJSONRPCResult(id, buildModernResult({}, this.#options.identity));
 	}
 	#contain(error, id) {
@@ -5440,19 +5674,19 @@ var MCPServer = class {
 //#endregion
 //#region src/core/MCPTaskClient.ts
 /**
-* The CLIENT half of the stable Tasks extension — the `tasks/*` methods over one
-* correlated-request door, exposed as an {@link import('./types.js').MCPClientInterface}'s
+* 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
@@ -5500,20 +5734,20 @@ var MCPTaskClient = class {
 //#endregion
 //#region src/core/MCPClient.ts
 /**
-* A transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE MCP server
-* over an injected {@link MCPClientTransportInterface}, negotiates the modern revision, and
-* exposes the server's tools as local {@link ToolInterface}s an agent can run.
+* 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
@@ -5521,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
@@ -5540,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);
@@ -5593,7 +5827,7 @@ var MCPClient = class {
 		});
 		this.#transport = options.transport;
 		this.#identity = options.identity ?? {
-			name: "taverna",
+			name: "@orkestrel/mcp",
 			version: "1.0.0"
 		};
 		this.#capabilities = options.capabilities ?? {};
@@ -5734,18 +5968,19 @@ var MCPClient = class {
 				} }
 			}
 		};
-		const subscription = {
-			queue: [],
-			capacity
-		};
 		const abort = this.#abortSubscription.bind(this, id, signal);
 		signal.addEventListener("abort", abort, { once: true });
 		this.#pending.set(id, {
 			method,
 			signal,
 			abort,
-			subscription
+			subscription: {
+				queue: [],
+				capacity
+			}
 		});
+		const subscription = this.#pending.get(id)?.subscription;
+		if (subscription === void 0) throw new Error("MCP subscription state is missing");
 		this.#transport.send(request).catch((error) => this.#settle(id, error, true));
 		try {
 			for (;;) {
@@ -6071,13 +6306,222 @@ var MCPClient = class {
 	}
 };
 //#endregion
+//#region src/core/transports/HTTPClientTransport.ts
+/**
+* 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`.
+*
+* @remarks
+* - **One class, both faces.** It touches `fetch`, `Response`, `AbortController`,
+*   `AbortSignal`, and `WeakMap` alone, so it is host-independent and lives in core. Each
+*   environment face publishes its own `createHTTPClientTransport` over it —
+*   `@orkestrel/mcp/browser` and `@orkestrel/mcp/server` — and both factories return this
+*   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
+*   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
+*   to.
+* - **Both reply framings.** A `200` with an `application/json` body is parsed with
+*   `parseJSONRPCMessage`; a `200` with a `text/event-stream` body is decoded with the
+*   `@orkestrel/sse` {@link import('@orkestrel/sse').SSEParserInterface} ({@link
+*   readEventStream}) — the inverse of the server's `createStream` seam, so the wire
+*   round-trips. A `202`
+*   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
+*   `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
+*   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.
+*   Before initialize returns, neither captured legacy header is sent.
+*   `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
+*   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
+*   (`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
+*   caller's request with silence would leave it waiting out its own deadline for a failure
+*   the transport already read. A valid JSON-RPC error body is emitted at any HTTP status,
+*   because the protocol carries that outcome in band. A `fetch` or decode failure on a
+*   success response surfaces on the `error` event rather than escaping `send`.
+* - **Observable.** Owns the `emitter` ({@link MCPMessageTransportEventMap}); fires
+*   `message` per decoded reply, `error` on a fault, and `close` on `close()`.
+*
+* @example
+* ```ts
+* const transport = new HTTPClientTransport({ url: 'http://localhost:3000/mcp' })
+* const client = new MCPClient({ transport })
+* await client.connect()
+* ```
+*/
+var HTTPClientTransport = class {
+	#emitter;
+	#url;
+	#headers;
+	#fetch;
+	#timeout;
+	#pending = /* @__PURE__ */ new Set();
+	#parameters = /* @__PURE__ */ new Map();
+	#stamps = /* @__PURE__ */ new WeakMap();
+	#session = void 0;
+	#protocol = void 0;
+	#generation = 0;
+	#closed = false;
+	constructor(options) {
+		this.#emitter = new Emitter();
+		this.#url = options.url;
+		this.#headers = options.headers ?? {};
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#timeout = options.timeout;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get session() {
+		return this.#session;
+	}
+	get duplex() {
+		return false;
+	}
+	async start() {
+		this.#closed = false;
+	}
+	async send(message) {
+		this.#stamp(message);
+		const request = new AbortController();
+		this.#pending.add(request);
+		try {
+			await this.#exchange(message, request.signal);
+		} finally {
+			this.#pending.delete(request);
+		}
+	}
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const request of this.#pending) request.abort();
+		this.#pending.clear();
+		this.#protocol = void 0;
+		this.#emitter.emit("close");
+	}
+	#stamp(message) {
+		if (!isModernRequest(message) || message.method !== "tools/list") return;
+		if (message.params?.["cursor"] === void 0) this.#generation += 1;
+		this.#stamps.set(message, this.#generation);
+	}
+	async #exchange(message, signal) {
+		let response;
+		try {
+			response = await this.#fetch(this.#url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json, text/event-stream",
+					...this.#session === void 0 ? {} : { [MCP_SESSION_HEADER]: this.#session },
+					...this.#buildHeaders(message),
+					...this.#headers
+				},
+				body: JSON.stringify(message),
+				signal: this.#timeout === void 0 ? signal : AbortSignal.any([signal, AbortSignal.timeout(this.#timeout)])
+			});
+		} catch (error) {
+			this.#emitter.emit("error", error);
+			return;
+		}
+		const session = response.headers.get(MCP_SESSION_HEADER);
+		if (session !== null) this.#session = session;
+		await this.#deliver(response, message);
+	}
+	#buildHeaders(message) {
+		if (isModernRequest(message)) {
+			const version = inferRequestVersion(message);
+			const name = message.params?.["name"];
+			return {
+				...version === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: version },
+				[MCP_METHOD_HEADER]: message.method,
+				...message.method === "tools/call" && isString(name) ? {
+					[MCP_NAME_HEADER]: encodeSentinel(name),
+					...buildHeaderProjection(this.#parameters.get(name) ?? [], message.params?.["arguments"])
+				} : {}
+			};
+		}
+		return this.#protocol === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: this.#protocol };
+	}
+	async #deliver(response, sent) {
+		if (response.status === 202) return;
+		const type = response.headers.get("content-type") ?? "";
+		let messages = [];
+		let failure;
+		try {
+			if (type.includes("text/event-stream")) messages = await readEventStream(response);
+			else if (type.includes("application/json")) {
+				const message = parseJSONRPCMessage(await response.json());
+				if (message !== void 0) messages = [message];
+			}
+		} catch (error) {
+			failure = { error };
+		}
+		for (const message of messages) this.#capture(message, sent);
+		if (!response.ok && messages.length === 0) throw buildResponseError(response, type);
+		if (failure !== void 0) this.#emitter.emit("error", failure.error);
+	}
+	#capture(message, sent) {
+		if (isJSONRPCResponse(message) && isRecord(message.result) && isMCPVersion(message.result["protocolVersion"])) this.#protocol = message.result["protocolVersion"];
+		this.#emitter.emit("message", this.#select(message, sent));
+	}
+	#select(message, sent) {
+		if (!isModernRequest(sent) || sent.method !== "tools/list") return message;
+		if (!isJSONRPCResponse(message) || message.error !== void 0) return message;
+		const result = message.result;
+		const listed = isRecord(result) ? result["tools"] : void 0;
+		if (!isRecord(result) || !isArray(listed)) return message;
+		const current = this.#stamps.get(sent) === this.#generation;
+		if (current && sent.params?.["cursor"] === void 0) this.#parameters.clear();
+		const kept = [];
+		for (const tool of listed) {
+			if (!isRecord(tool) || !isString(tool["name"])) {
+				kept.push(tool);
+				continue;
+			}
+			const parameters = buildHeaderParameters(tool["inputSchema"]);
+			if (parameters === void 0) {
+				this.#emitter.emit("error", /* @__PURE__ */ new Error(`MCP tool '${tool["name"]}' is excluded from tools/list: its inputSchema carries an invalid x-mcp-header annotation`));
+				continue;
+			}
+			if (current) this.#parameters.set(tool["name"], parameters);
+			kept.push(tool);
+		}
+		return {
+			...message,
+			result: {
+				...result,
+				tools: kept
+			}
+		};
+	}
+};
+//#endregion
 //#region src/core/factories.ts
 /**
 * Creates a transport-agnostic Model Context Protocol server — exposes a live
 * {@link import('@orkestrel/tool').ToolManagerInterface} and an optional
 * {@link import('./types.js').MCPResourceManagerInterface},
 * {@link import('./types.js').MCPPromptManagerInterface}, and
-* {@link import('./types.js').MCPCompletionManagerInterface} over JSON-RPC 2.0.
+* {@link import('./types.js').MCPCompletionInterface} over JSON-RPC 2.0.
 *
 * @remarks
 * Pump raw message strings through `handle` (parse → dispatch → serialize) from a
@@ -6096,20 +6540,35 @@ var MCPClient = 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) {
@@ -6118,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
 */
@@ -6128,14 +6591,14 @@ function createMCPLegacy(server) {
 	});
 }
 /**
-* Creates a transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE
-* MCP server over an injected {@link import('./types.js').MCPClientTransportInterface},
+* 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),
@@ -6145,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}
@@ -6160,7 +6623,7 @@ function createMCPLegacy(server) {
 * })
 * await client.connect()
 * agent.context.tools.add(await client.tools()) // give the agent the remote tools
-* const value = await client.call('search', { query: 'mcp' })
+* const outcome = await client.call('search', { query: 'mcp' })
 * ```
 */
 function createMCPClient(options) {
@@ -6186,12 +6649,12 @@ function createMCPLegacyClientTransport(transport, options) {
 }
 /**
 * Adapts an {@link MCPTransportInterface} (the environment-agnostic duplex message
-* channel) into a {@link MCPClientTransportInterface} — the additive bridge that lets
+* channel) into a {@link MCPMessageTransportInterface} — the additive bridge that lets
 * `createMCPClient` run over the new port without any change to `MCPClient`'s
 * 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
@@ -6199,17 +6662,17 @@ 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`-
 * capable emitter for `bindClient` to push onto.
 *
 * @param transport - The duplex channel to adapt
-* @returns A {@link MCPClientTransportInterface} `createMCPClient` can drive
+* @returns A {@link MCPMessageTransportInterface} `createMCPClient` can drive
 *
 * @example
 * ```ts
@@ -6233,6 +6696,6 @@ function createDuplexClientTransport(transport) {
 	};
 }
 //#endregion
-export { DEFAULT_MCP_CACHE_TTL, DEFAULT_MCP_CLIENT_NAME, DEFAULT_MCP_CLIENT_VERSION, DEFAULT_MCP_LIMITS, DEFAULT_MCP_REQUEST_TIMEOUT, DEFAULT_MCP_SUBSCRIPTION_CAPACITY, EMPTY_MCP_ARGUMENTS, JSONRPC_INTERNAL_ERROR, JSONRPC_INVALID_PARAMS, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, JSONRPC_SERVER_ERROR, MCPClient, MCPError, MCPLegacy, MCPLegacyClientTransport, MCPMethodManager, MCPProgressReporter, MCPServer, MCPStreamController, MCPTaskClient, MCPTextStreamController, MCP_EXTENSION_TASKS, MCP_FALLBACK_VERSION, MCP_HANDSHAKE_VERSION, MCP_HEADER_ANNOTATION, MCP_HEADER_MISMATCH, MCP_LOOKUP_PAGES, MCP_META_CAPABILITIES, MCP_META_CLIENT, MCP_META_SERVER, MCP_META_SUBSCRIPTION, MCP_META_VERSION, MCP_MISSING_CAPABILITY, MCP_MODERN_VERSION, MCP_PARAM_PREFIX, MCP_SENTINEL_PREFIX, MCP_SENTINEL_SUFFIX, MCP_UNSUPPORTED_VERSION, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, SUPPORTED_MCP_VERSIONS, SUPPORTED_MODERN_PROTOCOL_VERSIONS, bindClient, bindServer, buildCallOutcome, buildCancelledNotification, buildDiscoverResult, buildHeaderParameters, buildHeaderProjection, buildInitializeResult, buildJSONRPCError, buildJSONRPCResult, buildMethodOptions, buildModernResult, buildProgressNotification, buildSubscriptionAcknowledgement, buildSubscriptionFilter, buildSubscriptionResult, buildToolCall, buildToolDescriptors, computeMissingCapabilities, countHeaderAnnotations, createDuplexClientTransport, createMCPClient, createMCPLegacy, createMCPLegacyClientTransport, createMCPServer, decodeBoundedMessage, decodeSentinel, digestJSON, encodeSentinel, extractContentText, extractHeaderAnnotations, extractToolSchema, inferEra, inferRequestVersion, inferVersion, isAbsoluteURI, isBoundedJSON, isBoundedString, isElicitContent, isFieldToken, isFormElicitationSupported, isInitializeRequest, isJSONObject, isJSONRPCError, isJSONRPCErrorResponse, isJSONRPCId, isJSONRPCInvocation, isJSONRPCMessage, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isMCPAnnotations, isMCPBlobResource, isMCPCallResult, isMCPClientCapabilities, isMCPCompletion, isMCPCompletionParams, isMCPCompletionReference, isMCPCompletionResult, isMCPContent, isMCPElicitFieldSchema, isMCPElicitForm, isMCPElicitRequest, isMCPElicitResult, isMCPElicitSchema, isMCPElicitURL, isMCPError, isMCPHeaderPrimitive, isMCPIcon, isMCPIdentity, isMCPInputRequest, isMCPInputRequestMap, isMCPInputResponse, isMCPInputResult, isMCPLegacyResult, isMCPLegacyVersion, isMCPLoggingLevel, isMCPMetaKey, isMCPMetaObject, isMCPModernVersion, isMCPNotificationMetaObject, isMCPPaginationParams, isMCPProgress, isMCPPrompt, isMCPPromptArgument, isMCPPromptGetResult, isMCPPromptMessage, isMCPPromptPage, isMCPResource, isMCPResourceContents, isMCPResourcePage, isMCPResourceTemplate, isMCPResourceTemplatePage, isMCPResult, isMCPResultMetaObject, isMCPRoot, isMCPRootResult, isMCPSampleContent, isMCPSampleResult, isMCPServerCapabilities, isMCPStringArguments, isMCPSubscriptionFilter, isMCPSubscriptionResult, isMCPTaskDetail, isMCPTaskDetailResult, isMCPTaskNotification, isMCPTaskResult, isMCPTaskStatus, isMCPTextResource, isMCPVersion, isModernRequest, isRFC3339Date, isRFC3339DateTime, isStandardBase64, isTaskSupported, legacyInvocationToModern, legacyResultToModern, matchesResultType, matchesSubscriptionNotification, modernInvocationToLegacy, modernResultToLegacy, parseJSONRPCMessage, parseMCPInputState, parseRequestContext, readCancelledId, renderHeaderValue, sendStream, serializeJSON, snapshotJSON, snapshotToolResult, stampSubscriptionNotification };
+export { DEFAULT_MCP_CACHE_TTL, DEFAULT_MCP_CLIENT_NAME, DEFAULT_MCP_CLIENT_VERSION, DEFAULT_MCP_LIMITS, DEFAULT_MCP_REQUEST_TIMEOUT, DEFAULT_MCP_SUBSCRIPTION_CAPACITY, EMPTY_MCP_ARGUMENTS, HTTPClientTransport, JSONRPC_INTERNAL_ERROR, JSONRPC_INVALID_PARAMS, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, JSONRPC_SERVER_ERROR, MCPClient, MCPError, MCPLegacy, MCPLegacyClientTransport, MCPMethodManager, MCPProgressReporter, MCPServer, MCPStreamController, MCPTaskClient, MCPTextStreamController, MCP_EXTENSION_TASKS, MCP_FALLBACK_VERSION, MCP_HANDSHAKE_VERSION, MCP_HEADER_ANNOTATION, MCP_HEADER_MISMATCH, MCP_LOOKUP_PAGES, MCP_META_CAPABILITIES, MCP_META_CLIENT, MCP_META_SERVER, MCP_META_SUBSCRIPTION, MCP_META_VERSION, MCP_METHOD_HEADER, MCP_MISSING_CAPABILITY, MCP_MODERN_VERSION, MCP_NAME_HEADER, MCP_PARAM_PREFIX, MCP_PROTOCOL_VERSION_HEADER, MCP_SENTINEL_PREFIX, MCP_SENTINEL_SUFFIX, MCP_SESSION_HEADER, MCP_UNSUPPORTED_VERSION, MCP_WEBSOCKET_SUBPROTOCOL, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, SUPPORTED_MCP_VERSIONS, SUPPORTED_MODERN_PROTOCOL_VERSIONS, bindClient, bindServer, buildCallOutcome, buildCancelledNotification, buildDiscoverResult, buildHeaderParameters, buildHeaderProjection, buildInitializeResult, buildJSONRPCError, buildJSONRPCResult, buildMethodOptions, buildModernResult, buildProgressNotification, buildResponseError, buildSubscriptionAcknowledgement, buildSubscriptionFilter, buildSubscriptionResult, buildToolCall, buildToolDescriptors, computeMissingCapabilities, countHeaderAnnotations, createDuplexClientTransport, createMCPClient, createMCPLegacy, createMCPLegacyClientTransport, createMCPServer, decodeBoundedMessage, decodeEvent, decodeSentinel, deliverMessage, digestJSON, encodeSentinel, extractContentText, extractHeaderAnnotations, extractToolSchema, inferEra, inferRequestEra, inferRequestVersion, inferVersion, isAbsoluteURI, isBoundedJSON, isBoundedString, isElicitContent, isFieldToken, isInitializeRequest, isJSONObject, isJSONRPCError, isJSONRPCErrorResponse, isJSONRPCId, isJSONRPCInvocation, isJSONRPCMessage, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isMCPAnnotations, isMCPBlobResource, isMCPCallResult, isMCPClientCapabilities, isMCPCompletion, isMCPCompletionParams, isMCPCompletionReference, isMCPCompletionResult, isMCPContent, isMCPElicitFieldSchema, isMCPElicitForm, isMCPElicitRequest, isMCPElicitResult, isMCPElicitSchema, isMCPElicitURL, isMCPError, isMCPHeaderPrimitive, isMCPIcon, isMCPIdentity, isMCPInputRequest, isMCPInputRequestMap, isMCPInputResponse, isMCPInputResult, isMCPLegacyResult, isMCPLegacyVersion, isMCPLoggingLevel, isMCPMetaKey, isMCPMetaObject, isMCPModernVersion, isMCPNotificationMetaObject, isMCPPaginationParams, isMCPProgress, isMCPPrompt, isMCPPromptArgument, isMCPPromptGetResult, isMCPPromptMessage, isMCPPromptPage, isMCPResource, isMCPResourceContents, isMCPResourcePage, isMCPResourceTemplate, isMCPResourceTemplatePage, isMCPResult, isMCPResultMetaObject, isMCPRoot, isMCPRootResult, isMCPSampleContent, isMCPSampleResult, isMCPServerCapabilities, isMCPStringArguments, isMCPSubscriptionFilter, isMCPSubscriptionResult, isMCPTaskDetail, isMCPTaskDetailResult, isMCPTaskNotification, isMCPTaskResult, isMCPTaskStatus, isMCPTextResource, isMCPVersion, isModernRequest, isRFC3339Date, isRFC3339DateTime, isStandardBase64, legacyInvocationToModern, legacyResultToModern, matchesResultType, matchesSubscriptionNotification, modernInvocationToLegacy, modernResultToLegacy, parseJSONRPCMessage, parseMCPInputState, parseRequestContext, readCancelledId, readEventStream, renderHeaderValue, sendStream, serializeJSON, snapshotJSON, snapshotToolResult, stampSubscriptionNotification, supportsFormElicitation, supportsTask };
 
 //# sourceMappingURL=index.js.map