@orkestrel/mcp 0.0.28 → 0.0.29

package/dist/src/core/index.d.ts

@@ -1,15 +1,15 @@
-import { EmitterErrorHandler } from '@orkestrel/emitter';
-import { EmitterHooks } from '@orkestrel/emitter';
-import { EmitterInterface } from '@orkestrel/emitter';
-import { JSONValue } from '@orkestrel/contract';
-import { ToolCall } from '@orkestrel/tool';
-import { ToolInterface } from '@orkestrel/tool';
-import { ToolManagerInterface } from '@orkestrel/tool';
-import { ToolResult } from '@orkestrel/tool';
+import type { EmitterErrorHandler } from '@orkestrel/emitter';
+import type { EmitterHooks } from '@orkestrel/emitter';
+import type { EmitterInterface } from '@orkestrel/emitter';
+import type { JSONValue } from '@orkestrel/contract';
+import type { ToolCall } from '@orkestrel/tool';
+import type { ToolInterface } from '@orkestrel/tool';
+import type { ToolManagerInterface } from '@orkestrel/tool';
+import type { ToolResult } from '@orkestrel/tool';
 
 /**
  * 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.
  *
@@ -17,30 +17,30 @@ import { ToolResult } from '@orkestrel/tool';
  * The client's outbound writes flow through `client.transport.send` — its existing,
  * unmodified request/response correlation — so `client` must have been constructed
  * with a {@link import('./types.js').MCPMessageTransportInterface} that itself carries
- * the SAME `transport` (see {@link import('./factories.js').createDuplexClientTransport},
+ * the same `transport` (see {@link import('./factories.js').createDuplexClientTransport},
  * the additive factory that adapts an {@link MCPTransportInterface} into that shape);
  * this binder then completes the inbound half by decoding each message and pushing it
  * onto `client.transport.emitter` (an {@link import('@orkestrel/emitter').EmitterInterface}
  * exposes `emit`, so no client modification is needed). A malformed / non-JSON-RPC
- * inbound message is DROPPED (total — never throws); a delivery fault is routed to
+ * inbound message is dropped (total — never throws); a delivery fault is routed to
  * `client.transport.emitter`'s `error` event (never rethrown). The returned unbind
- * DETACHES this binder (further inbound messages and the transport's `closed` signal are
- * ignored) WITHOUT closing the transport.
+ * detaches this binder (further inbound messages and the transport's `closed` signal are
+ * ignored) without closing the transport.
  *
- * `listen`/`closed` are REPLACE semantics (§ port contract): the returned unbind
- * DETACHES by replacing this binder's own handlers with no-ops, so a subsequent
- * `bindClient` call on the SAME transport is never double-dispatched by a stale
+ * `listen`/`closed` are replace semantics (§ port contract): the returned unbind
+ * detaches by replacing this binder's own handlers with no-ops, so a subsequent
+ * `bindClient` call on the same transport is never double-dispatched by a stale
  * subscription left behind — an unbind→rebind cycle delivers exactly one `message`
  * emit per inbound reply.
  *
  * **This binder needs no live-request registry, and the asymmetry with {@link bindServer} is
- * real rather than an omission.** A server binder holds the lifetime of work it STARTED, so an
+ * real rather than an omission.** A server binder holds the lifetime of work it started, so an
  * inbound `notifications/cancelled` has something to reach; a client binder starts no work —
  * `MCPClient` already owns its pending entries and already writes the cancellation frame
  * itself when a caller's `signal` aborts, on a carrier declaring `duplex`. Adding a registry
- * here would be a second correlation table for ids the client is already correlating, and two
- * tables for one fact drift. The one obligation this binder does carry is delivery: a
- * malformed / non-JSON-RPC inbound message is DROPPED (total — never throws).
+ * here would be a second correlation table for ids the client is already correlating, and a
+ * pair of tables for one fact drift. The one obligation this binder does carry is delivery: a
+ * malformed / non-JSON-RPC inbound message is dropped (total — never throws).
  *
  * @param client - The transport-agnostic client whose transport to deliver messages onto
  * @param transport - The duplex channel to pipe the client over
@@ -66,36 +66,36 @@ export declare function bindClient(client: MCPClientInterface, transport: MCPTra
  * `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
@@ -119,12 +119,12 @@ export declare function bindServer(server: MCPDispatcherInterface, transport: MC
  * 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
@@ -145,7 +145,7 @@ export declare function buildCallOutcome(name: string, result: unknown): MCPCall
  * 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,
@@ -178,7 +178,7 @@ export declare function buildCancelledNotification(id: JSONRPCId, reason?: strin
  * `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
@@ -194,8 +194,8 @@ export declare function buildDiscoverResult(options: MCPServerOptions): MCPDisco
  *
  * @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
@@ -266,14 +266,14 @@ export declare function buildInitializeResult(name: string, version: string, req
  * 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
  */
 export declare function buildJSONRPCError(id: JSONRPCId | undefined, code: number, message: string, data?: unknown): JSONRPCErrorResponse;
@@ -297,11 +297,11 @@ export declare function buildJSONRPCResult(id: JSONRPCId, result: MCPResult | MC
  * 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
@@ -430,7 +430,7 @@ export declare function buildToolDescriptors(manager: ToolManagerInterface): rea
  * 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
@@ -442,7 +442,7 @@ export declare function buildToolDescriptors(manager: ToolManagerInterface): rea
  * 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
@@ -465,7 +465,7 @@ export declare function computeMissingCapabilities(requests: MCPInputRequestMap,
  *
  * @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`
@@ -492,7 +492,7 @@ export declare function countHeaderAnnotations(value: unknown): number;
  * 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
@@ -500,10 +500,10 @@ export declare function countHeaderAnnotations(value: unknown): number;
  * 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`-
@@ -522,14 +522,14 @@ export declare function countHeaderAnnotations(value: unknown): number;
 export declare function createDuplexClientTransport(transport: MCPTransportInterface): MCPMessageTransportInterface;
 
 /**
- * Creates a transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE
+ * Creates a transport-agnostic Model Context Protocol client — connects to a remote
  * MCP server over an injected {@link import('./types.js').MCPMessageTransportInterface},
  * negotiates the modern revision through `server/discover`, and exposes the server's tools as local
  * {@link import('@orkestrel/tool').ToolInterface}s an agent can run.
  *
  * @remarks
  * The egress mirror of {@link createMCPServer}: where the server exposes a local tool
- * registry over MCP, the client USES a remote server's tools. `connect()` discovers,
+ * registry over MCP, the client uses a remote server's tools. `connect()` discovers,
  * validates, and exposes the negotiated modern protocol; a legacy peer requires
  * {@link createMCPLegacyClientTransport}. `tools()` lists + wraps the remote
  * tools (each `execute` calls back over the wire),
@@ -539,7 +539,7 @@ export declare function createDuplexClientTransport(transport: MCPTransportInter
  * `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}
@@ -562,6 +562,10 @@ export declare function createMCPClient(options: MCPClientOptions): MCPClientInt
 /**
  * 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
  */
@@ -608,20 +612,35 @@ export declare function createMCPLegacyClientTransport(transport: MCPMessageTran
  *   {@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"}}}}'
  * ```
  */
 export declare function createMCPServer(options: MCPServerOptions): MCPServerInterface;
@@ -631,7 +650,7 @@ export declare function createMCPServer(options: MCPServerOptions): MCPServerInt
  * before it hands the string on.
  *
  * @remarks
- * The bound is checked FIRST, against the raw string, so an oversized message is never
+ * The bound is checked first, against the raw string, so an oversized message is never
  * parsed at all: a decoder that parses before it measures has already spent the work
  * the bound exists to refuse. A message over the bound, malformed JSON, and a well-formed
  * value that is not a JSON-RPC message are one answer — `undefined` — because a binder does
@@ -686,7 +705,7 @@ export declare function decodeEvent(data: string): JSONRPCMessage | undefined;
  * 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.
  *
@@ -779,12 +798,12 @@ export declare const DEFAULT_MCP_SUBSCRIPTION_CAPACITY = 64;
  * Decodes one inbound frame and delivers it onto a transport emitter as `message` or `error`.
  *
  * @remarks
- * The ONE inbound fold every message-carrying transport in this package runs: parse the frame,
+ * The one inbound fold every message-carrying transport in this package runs: parse the frame,
  * narrow it with `parseJSONRPCMessage`, emit `message` for a well-formed
  * {@link JSONRPCMessage}, and emit `error` for anything else. Total — an adversarial frame
  * produces an `error` emission and never a throw.
  *
- * The two failures report differently on purpose. Unparsable text emits the CAUGHT parse
+ * The failures report differently on purpose. Unparsable text emits the caught parse
  * error, which names the offending position; well-formed JSON that is not a JSON-RPC message
  * has no caught value to report, so it emits `fault` — the carrier's own wording, passed in
  * rather than forked into a second copy of this body.
@@ -813,7 +832,7 @@ export declare function digestJSON(value: unknown, limits: MCPJSONLimitOptions):
  * 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
@@ -830,7 +849,7 @@ export declare const EMPTY_MCP_ARGUMENTS: Readonly<Record<string, unknown>>;
  *
  * @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
@@ -867,9 +886,9 @@ export declare function encodeSentinel(value: string): string;
  * 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
@@ -890,12 +909,12 @@ export declare function extractContentText(result: unknown): string;
  * 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
@@ -934,7 +953,7 @@ export declare function extractHeaderAnnotations(schema: unknown, path: readonly
 export declare function extractToolSchema(response: unknown, name: string): Readonly<Record<string, unknown>> | undefined;
 
 /**
- * Drives a REMOTE Streamable-HTTP MCP server over `fetch` — a CLIENT
+ * Drives a remote Streamable-HTTP MCP server over `fetch` — a client
  * {@link MCPMessageTransportInterface} for the Model Context Protocol, the egress mirror of
  * the server's `createMCPRoutes`.
  *
@@ -946,7 +965,7 @@ export declare function extractToolSchema(response: unknown, name: string): Read
  *   class, so a reply reaches a page and a Node process through the same decode.
  * - **Request/response over `fetch`.** `send(message)` POSTs the JSON-serialized
  *   message to `options.url` with `content-type: application/json` and an
- *   `Accept` of BOTH `application/json` and `text/event-stream` (so the server may
+ *   `Accept` of both `application/json` and `text/event-stream` (so the server may
  *   answer with either framing) — plus any `options.headers` (for example, an `Authorization`
  *   bearer). It then decodes the reply and emits each decoded {@link JSONRPCMessage} on
  *   the `message` event the {@link import('@orkestrel/mcp').MCPClientInterface} subscribes
@@ -959,12 +978,12 @@ export declare function extractToolSchema(response: unknown, name: string): Read
  *   Accepted (a notification) carries no body and emits nothing.
  * - **Session and protocol headers.** `start()` is a no-op (a
  *   request/response transport opens no long-lived connection). The
- *   `mcp-session-id` response header, when a STATEFUL server sends one (on
- *   `initialize`), is captured into `session` and then ECHOED as the
- *   `mcp-session-id` request header on every SUBSEQUENT request — so an
+ *   `mcp-session-id` response header, when a stateful server sends one (on
+ *   `initialize`), is captured into `session` and then echoed as the
+ *   `mcp-session-id` request header on every subsequent request — so an
  *   `MCPClient` passes a stateful server's session validation. The
  *   initialize result's `protocolVersion` is likewise captured, but only
- *   when it is a SUPPORTED value, and echoed as `mcp-protocol-version` alone on
+ *   when it is a supported value, and echoed as `mcp-protocol-version` alone on
  *   subsequent legacy requests. Modern requests instead derive protocol and method
  *   headers from the message, plus the name header only for `tools/call` — carried in the
  *   protocol's Base64 sentinel form whenever the tool name cannot ride as plain ASCII.
@@ -972,11 +991,11 @@ export declare function extractToolSchema(response: unknown, name: string): Read
  *   `close()` clears the captured protocol so a reconnect's `initialize`
  *   POST is headerless; the captured `session` persists across `close()`.
  * - **`close()` releases what is in flight.** Every `fetch` this transport still has open is
- *   ABORTED, which cancels the response body a `send` is reading — an SSE reply the server
+ *   aborted, which cancels the response body a `send` is reading — an SSE reply the server
  *   never ends would otherwise outlive the transport, with nothing left able to reach it. The
  *   aborted read surfaces on `error` and the `send` reporting it resolves. `close()` is
  *   idempotent (one `close` event per connected lifetime), and `start()` opens the next one.
- * - **Total at the boundary, and a non-success reply REJECTS.** Every reply is narrowed
+ * - **Total at the boundary, and a non-success reply rejects.** Every reply is narrowed
  *   (`parseJSONRPCMessage`, the SSE decoder). A non-message success reply is dropped, never
  *   asserted. A non-success reply that carries no valid JSON-RPC message rejects `send` with
  *   an error naming its HTTP status and body shape — the peer answered, and answering the
@@ -1012,7 +1031,7 @@ export declare class HTTPClientTransport implements MCPMessageTransportInterface
  * @remarks
  * - `url` — the absolute URL of the remote server's Streamable-HTTP endpoint (the
  *   `POST` target every JSON-RPC message is written to, for example,
- *   `http://localhost:3000/mcp`). REQUIRED.
+ *   `http://localhost:3000/mcp`). Required.
  * - `headers` — extra request headers merged onto every `POST` (for example, an
  *   `Authorization` bearer for a guarded server). The transport always sets
  *   `content-type: application/json` and an `Accept` of both `application/json` and
@@ -1038,9 +1057,9 @@ export declare interface HTTPClientTransportOptions {
  * 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
@@ -1052,10 +1071,10 @@ export declare function inferEra(version: string): MCPEra | undefined;
  * Infers the wire era one invocation's own structure selects.
  *
  * @remarks
- * The STRUCTURAL read, distinct from {@link inferEra}'s read of a revision string: era is fixed
+ * The structural read, distinct from {@link inferEra}'s read of a revision string: era is fixed
  * by the reserved modern metadata a request carries, so this answers for a message whose
  * revision has not been read and cannot answer `undefined` — every invocation took one of the
- * two published wire shapes. It is what an observation surface reports and what an ingress
+ * published wire shapes. It is what an observation surface reports and what an ingress
  * routes on, so both derive it here rather than each spelling the ternary out.
  *
  * @param invocation - The invocation whose structure selects the era
@@ -1069,15 +1088,15 @@ export declare function inferEra(version: string): MCPEra | undefined;
 export declare function inferRequestEra(invocation: JSONRPCInvocation): MCPEra;
 
 /**
- * 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
@@ -1086,7 +1105,7 @@ export declare function inferRequestEra(invocation: JSONRPCInvocation): MCPEra;
  * 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
@@ -1157,13 +1176,13 @@ export declare function isBoundedString(value: unknown, bytes: number): value is
  * 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`
@@ -1172,9 +1191,9 @@ export declare function isBoundedString(value: unknown, bytes: number): value is
  * `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.
  *
@@ -1238,17 +1257,17 @@ export declare function isJSONObject(value: unknown): value is Readonly<Record<s
  * 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.
  *
@@ -1268,9 +1287,9 @@ export declare function isJSONRPCError(value: unknown): value is JSONRPCError;
  * 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
@@ -1338,7 +1357,7 @@ export declare function isJSONRPCMessage(value: unknown): value is JSONRPCMessag
  * 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`.
  *
@@ -1358,7 +1377,7 @@ export declare function isJSONRPCNotification(value: unknown): value is JSONRPCN
  *
  * @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
@@ -1392,8 +1411,8 @@ export declare function isJSONRPCResponse(value: unknown): value is JSONRPCRespo
  * 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.
@@ -1644,12 +1663,12 @@ export declare function isMCPInputRequestMap(value: unknown): value is MCPInputR
  * 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
@@ -1731,8 +1750,8 @@ export declare function isMCPModernVersion(value: unknown): value is MCPModernVe
  * 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
@@ -1852,7 +1871,7 @@ export declare function isMCPResourceTemplatePage(value: unknown): value is MCPR
  *
  * @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
@@ -1939,10 +1958,11 @@ export declare function isMCPSampleContent(value: unknown): value is MCPSampleCo
  *
  * @remarks
  * The schema's `CreateMessageResult` types `content` as an `anyOf` over one
- * {@link isMCPSampleContent} block or an ARRAY of them, so both are admitted here: a
+ * {@link isMCPSampleContent} block or an array of them, so both are admitted here: a
  * tool-using model answers with `tool_use` and `tool_result` blocks, and a model answering in
  * several parts answers with the array. `stopReason` stays an open string because the schema
- * names four values and permits any other a provider reports. Total over hostile input.
+ * names `endTurn`, `stopSequence`, `maxTokens`, and `toolUse` and permits any other a provider
+ * reports. Total over hostile input.
  *
  * @param value - The unknown value to inspect
  * @returns True if `value` has the sampling-completion shape; false otherwise
@@ -2010,7 +2030,7 @@ export declare function isMCPSubscriptionResult(value: unknown): value is MCPSub
  * 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.
@@ -2036,11 +2056,11 @@ export declare function isMCPTaskDetail(value: unknown): value is MCPTaskDetail;
  * 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
@@ -2063,14 +2083,14 @@ export declare function isMCPTaskDetailResult(value: unknown): value is MCPTaskD
  * 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
@@ -2096,7 +2116,7 @@ export declare function isMCPTaskNotification(value: unknown): value is MCPTaskN
  * proof: this is what stands between a manager that answers a numeric `taskId` and a
  * client that would receive one. `ttlMs` accepts `null` because the schema uses it to
  * mean "no expiry", which is distinct from an absent field, and both durations must be
- * INTEGER milliseconds because the schema formats them `int`.
+ * integer milliseconds because the schema formats them `int`.
  *
  * @param value - The unknown value to inspect
  * @returns True if the value is a well-formed `resultType: 'task'` result; false otherwise
@@ -2158,7 +2178,7 @@ export declare function isModernRequest(value: unknown): value is JSONRPCInvocat
  * 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
@@ -2166,7 +2186,7 @@ export declare function isModernRequest(value: unknown): value is JSONRPCInvocat
  *
  * The check is pure integer arithmetic on the matched fields and never constructs a `Date`,
  * because `Date` is exactly the component that performs the rollover this guard exists to
- * refuse. It is a SYNTAX guard: no time zone, locale, calendar era, or leap second applies.
+ * refuse. It is a syntax guard: no time zone, locale, calendar era, or leap second applies.
  *
  * @param value - The unknown value to inspect
  * @returns True if the value is an RFC 3339 `full-date` for a day that exists; false otherwise
@@ -2217,7 +2237,7 @@ export declare function isStandardBase64(value: unknown): value is string;
  * 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.
@@ -2240,7 +2260,7 @@ export declare const JSONRPC_PARSE_ERROR = -32700;
  * 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.
  */
@@ -2252,7 +2272,7 @@ export declare const JSONRPC_SERVER_ERROR = -32000;
  *
  * @remarks
  * `code` is one of the reserved JSON-RPC codes (see `./constants.js`); `message`
- * is a short human description; `data` is an OPTIONAL machine-readable payload
+ * is a short human description; `data` is an optional machine-readable payload
  * carrying extra detail.
  */
 export declare interface JSONRPCError {
@@ -2266,20 +2286,26 @@ export declare interface JSONRPCError {
  * the {@link JSONRPCError} that ended it.
  *
  * @remarks
- * `id` is OMITTED, never `null`, when the request could not be parsed or its id
+ * `id` is omitted, never `null`, when the request could not be parsed or its id
  * read: MCP overrides the base specification here, so a modern peer receives an
  * envelope with no `id` member at all. `result` is forbidden.
  */
 export declare interface JSONRPCErrorResponse {
     readonly jsonrpc: '2.0';
-    /** Holds the failed request's id; ABSENT when no id could be read. */
+    /** Holds the failed request's id; absent when no id could be read. */
     readonly id?: JSONRPCId;
     readonly error: JSONRPCError;
     /** Forbids this member; an answer carries a result or an error, never both. */
     readonly result?: never;
 }
 
-/** Represents a JSON-RPC 2.0 correlation id — the value a request and its response share. */
+/**
+ * Represents a JSON-RPC 2.0 correlation id — the value a request and its response share.
+ *
+ * @remarks
+ * `null` is not an id. A response that could not read one omits the member entirely, which is
+ * what {@link JSONRPCErrorResponse} declares.
+ */
 export declare type JSONRPCId = string | number;
 
 /**
@@ -2321,7 +2347,7 @@ export declare interface JSONRPCNotification {
 
 /**
  * Represents a JSON-RPC 2.0 request — a `method` call with optional `params`, correlated to
- * its response by the `id` it REQUIRES.
+ * its response by the `id` it requires.
  *
  * @remarks
  * `jsonrpc` is the literal `'2.0'`. A call with no `id` is not a request at all: it
@@ -2352,7 +2378,7 @@ export declare type JSONRPCResponse = JSONRPCResultResponse | JSONRPCErrorRespon
  *
  * @remarks
  * A result answers a request, and a request always has a readable `id`, so `id` is
- * REQUIRED here. `result` is an {@link MCPResult} on the modern wire and an
+ * required here. `result` is an {@link MCPResult} on the modern wire and an
  * {@link MCPLegacyResult} on the legacy one; `error` is forbidden.
  */
 export declare interface JSONRPCResultResponse {
@@ -2389,7 +2415,7 @@ export declare function legacyResultToModern(result: MCPLegacyResult, method: st
  * 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.
@@ -2424,19 +2450,23 @@ export declare function matchesSubscriptionNotification(notification: JSONRPCNot
  * 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.
  */
 export declare const MCP_EXTENSION_TASKS = "io.modelcontextprotocol/tasks";
 
-/** Names the older legacy revision the optional legacy decorator accepts and an adapter can pin. */
+/**
+ * Names the older legacy revision the optional legacy decorator accepts and an adapter can pin,
+ * `'2025-06-18'`.
+ */
 export declare const MCP_FALLBACK_VERSION: MCPLegacyVersion;
 
 /**
- * Names the revision offered and defaulted to in the legacy `initialize` handshake.
+ * Names the revision offered and defaulted to in the legacy `initialize` handshake,
+ * `'2025-11-25'`.
  *
  * @remarks
  * This is deliberately a legacy revision, and the newest one supported. 2026-07-28 is stateless
@@ -2449,7 +2479,7 @@ export declare const MCP_HANDSHAKE_VERSION: MCPLegacyVersion;
  * Identifies the tool-schema annotation key naming the header one parameter projects into.
  *
  * @remarks
- * It is valid ONLY on a primitive property schema statically reachable from the `inputSchema`
+ * It is valid only on a primitive property schema statically reachable from the `inputSchema`
  * root through `properties` keys alone. An occurrence anywhere else — under `items`, a
  * composition or conditional keyword, or a `$ref` target — makes the whole tool definition
  * invalid, which is what {@link import('@orkestrel/mcp').buildHeaderParameters} decides.
@@ -2503,7 +2533,7 @@ export declare const MCP_METHOD_HEADER = "mcp-method";
  * 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
@@ -2514,7 +2544,7 @@ export declare const MCP_METHOD_HEADER = "mcp-method";
  */
 export declare const MCP_MISSING_CAPABILITY = -32021;
 
-/** Names the modern revision offered by an unpinned client during discovery. */
+/** Names the modern revision offered by an unpinned client during discovery, `'2026-07-28'`. */
 export declare const MCP_MODERN_VERSION: MCPModernVersion;
 
 /**
@@ -2550,10 +2580,10 @@ export declare const MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
  * 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.
  */
 export declare const MCP_SENTINEL_PREFIX = "=?base64?";
 
@@ -2564,7 +2594,7 @@ export declare const MCP_SENTINEL_SUFFIX = "?=";
  * Names the Streamable-HTTP transport header that carries the MCP session id.
  *
  * @remarks
- * A STATEFUL server sends it on the `initialize` reply, and
+ * A stateful server sends it on the `initialize` reply, and
  * {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} echoes it as a
  * request header on every subsequent request, so a client passes that server's session
  * validation unchanged.
@@ -2621,10 +2651,10 @@ export declare interface MCPBlobResource {
  * @remarks
  * Each option lives for exactly one request:
  *
- * - `signal` cancels THAT request and nothing else. It never closes the connection, never
+ * - `signal` cancels that request and nothing else. It never closes the connection, never
  *   reaches a durable task the call may have become, and never asks the peer to undo work
  *   already done — cancellation is advisory in MCP, so the peer may finish anyway and the
- *   caller simply stops waiting. A signal that is ALREADY aborted refuses the call before
+ *   caller stops waiting. A signal that is already aborted refuses the call before
  *   anything is written, so no request the peer would have to be told about is ever issued.
  * - `progress` receives each `notifications/progress` frame the peer publishes for this
  *   request. Supplying it is what stamps the request's progress token, so a peer only
@@ -2660,9 +2690,9 @@ export declare interface MCPCallOptions {
  * - `'complete'` — the call finished. `value` is the tool's own value: the peer's
  *   `structuredContent` when it sent one (the tool's value in its original structure),
  *   and otherwise the concatenated `text` blocks parsed as JSON, falling back to the raw
- *   text. A tool FAILURE never reaches this arm — `isError: true` throws, so an agent's
+ *   text. A tool failure never reaches this arm — `isError: true` throws, so an agent's
  *   {@link ToolManagerInterface} isolates a remote failure exactly as it does a local one.
- * - {@link MCPTaskResult} — the server DEFERRED the call into a durable task. The request
+ * - {@link MCPTaskResult} — the server deferred the call into a durable task. The request
  *   is over and the work is not; the outcome arrives later through the task's own methods.
  * - {@link MCPInputResult} — the call needs another round trip before it can finish.
  *
@@ -2681,20 +2711,20 @@ export declare type MCPCallResult = MCPUnstampedCallResult & {
 };
 
 /**
- * Connects to a REMOTE MCP server over any injected {@link MCPMessageTransportInterface},
+ * Connects to a remote MCP server over any injected {@link MCPMessageTransportInterface},
  * negotiates the modern revision, and exposes the server's tools as local
  * {@link ToolInterface}s an agent can run.
  *
  * @remarks
- * - **The mirror of `MCPServer`.** The server DISPATCHES requests over a tool registry;
- *   this client ISSUES them over a transport. `connect` probes `server/discover` and exposes
+ * - **The mirror of `MCPServer`.** The server dispatches requests over a tool registry;
+ *   this client issues them over a transport. `connect` probes `server/discover` and exposes
  *   the negotiated `version`; a legacy peer requires an explicit transport adapter.
  *   `tools()` lists the remote tools and wraps each as a
  *   local {@link ToolInterface} whose `execute` calls back through `call`; `call` runs a
  *   remote `tools/call` and reports the arm the peer answered with — a value, a durable
  *   task, or a request for more input (a remote `isError: true` throws locally, so an
  *   agent's {@link import('@orkestrel/tool').ToolManagerInterface} isolates it into a
- *   `success: false` result just like a local throw). A wrapped tool cannot hand an agent
+ *   `success: false` result exactly like a local throw). A wrapped tool cannot hand an agent
  *   a deferred answer, so a non-`'complete'` arm throws there.
  * - **Request↔response correlation.** Each request is tagged with a monotonic numeric
  *   `id` ({@link #nextId}); a single transport `message` subscription resolves / rejects
@@ -2702,9 +2732,9 @@ export declare type MCPCallResult = MCPUnstampedCallResult & {
  *   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
@@ -2721,7 +2751,7 @@ export declare type MCPCallResult = MCPUnstampedCallResult & {
  *   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);
@@ -2783,13 +2813,13 @@ export declare type MCPClientCapabilities = Readonly<Record<string, MCPMetaObjec
  * - `disconnect` — the connection this client had announced ended (every pending request
  *   rejected, and the connection it owned on the transport closed — or that close faulted or
  *   timed out, which rejects the `disconnect` caller rather than withholding this event).
- * - `notification` — a server-initiated JSON-RPC NOTIFICATION arrived — forwarded for the
+ * - `notification` — a server-initiated JSON-RPC notification arrived — forwarded for the
  *   consumer to react to (for example, a `notifications/tools/list_changed`). A
  *   `notifications/progress` frame claimed by an in-flight request's progress handler is
- *   delivered there instead, and a RESPONSE correlating to nothing pending is discarded
+ *   delivered there instead, and a response correlating to nothing pending is discarded
  *   rather than forwarded here, because it answers a request that has already settled.
  * - `error` — a client-level fault surfaced for observation (typed `unknown`). This is
- *   a DOMAIN event, distinct from the emitter's own listener-error channel: a listener throw
+ *   a domain event, distinct from the emitter's own listener-error channel: a listener throw
  *   is routed to the emitter's `error` handler (the `error` option), never onto this map.
  *   Declared as a `type` alias so the literal satisfies `EventMap`.
  */
@@ -2805,13 +2835,13 @@ export declare type MCPClientEventMap = {
 };
 
 /**
- * Connects to a REMOTE MCP server over any injected {@link MCPMessageTransportInterface},
+ * Connects to a remote MCP server over any injected {@link MCPMessageTransportInterface},
  * negotiates the modern wire revision, and exposes the server's tools as local
  * {@link ToolInterface}s an agent can run.
  *
  * @remarks
- * - **The mirror of {@link MCPServerInterface}.** Where the server DISPATCHES requests
- *   over a tool registry, the client ISSUES them over a transport: `connect` negotiates through
+ * - **The mirror of {@link MCPServerInterface}.** Where the server dispatches requests
+ *   over a tool registry, the client issues them over a transport: `connect` negotiates through
  *   `server/discover`. A legacy peer requires an explicit
  *   {@link MCPLegacyClientTransportOptions legacy transport adapter}; the bare client refuses a
  *   peer that does not speak the modern era and names that adapter.
@@ -2819,11 +2849,11 @@ export declare type MCPClientEventMap = {
  *   the remote tools and wraps each as a local {@link ToolInterface} whose `execute`
  *   calls back through `call`; `call(name, args)` 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 tool FAILURE — `isError: true` — throws locally, so the agent's
- *   {@link ToolManagerInterface} isolates it into a `success: false` result just like a
+ *   (a remote tool failure — `isError: true` — throws locally, so the agent's
+ *   {@link ToolManagerInterface} isolates it into a `success: false` result exactly like a
  *   local throw). A wrapped tool has no way to hand an agent a deferred answer, so a
  *   non-`'complete'` arm throws there instead.
- * - **Per-request cancellation.** `call`'s `options.signal` cancels ONE in-flight request:
+ * - **Per-request cancellation.** `call`'s `options.signal` cancels one in-flight request:
  *   it rejects locally on every carrier, and additionally writes `notifications/cancelled`
  *   where the transport declares itself {@link MCPMessageTransportInterface.duplex}. It
  *   never cancels the connection, and never a durable task — a call that already answered
@@ -2832,17 +2862,17 @@ export declare type MCPClientEventMap = {
  * - **Durable tasks, no schedule.** `tasks` ({@link MCPTaskClientInterface}) reads, answers,
  *   and stops a task the peer deferred a call into. It carries the peer's `pollIntervalMs`
  *   datum and supplies the one-shot read; it starts no timer and keeps no cache, so a client
- *   left alone after a `resultType: 'task'` answer writes NOTHING until its consumer asks.
+ *   left alone after a `resultType: 'task'` answer writes nothing until its consumer asks.
  * - **Request↔response correlation.** Every request is tagged with a monotonic numeric
  *   `id`; the client subscribes to the transport's `message` event and resolves /
  *   rejects the matching pending request by that `id`. A server-initiated message is
  *   surfaced on `notification` — except a `notifications/progress` frame naming a request
  *   whose caller supplied a progress handler, which goes to that handler instead. A
- *   RESPONSE whose id matches nothing pending is DISCARDED: the request it answers has
+ *   response whose id matches nothing pending is discarded: the request it answers has
  *   already settled, by its deadline, by an abort, or by a disconnect, and the protocol
  *   says to ignore it rather than surface it as something a caller might act on.
  * - **Per-request deadline.** A request carrying a deadline races an
- *   `AbortSignal.timeout(timeout)`: a server that never replies REJECTS that pending
+ *   `AbortSignal.timeout(timeout)`: a server that never replies rejects that pending
  *   request once the deadline fires. The initial discovery probe and every public request use a
  *   deadline. An omitted `timeout` selects {@link DEFAULT_MCP_REQUEST_TIMEOUT}; an explicit
  *   timeout applies that deadline to the probe. The client's
@@ -2870,7 +2900,7 @@ export declare interface MCPClientInterface {
      *
      * @remarks
      * Always present, because the `tasks/*` methods are ordinary requests a client may
-     * issue at any time; whether they SUCCEED is the peer's decision, and a server that did not
+     * issue at any time; whether they succeed is the peer's decision, and a server that did not
      * configure the extension answers each of them `-32601`. Nothing here is advertised, cached, or
      * polled — see {@link MCPTaskClientInterface} for why the schedule stays the consumer's.
      */
@@ -2881,14 +2911,14 @@ export declare interface MCPClientInterface {
      *
      * @remarks
      * Idempotent — a second `connect` while already connected is a no-op, and one issued
-     * while the CURRENT attempt is in flight joins that attempt and returns its outcome
+     * while the current attempt is in flight joins that attempt and returns its outcome
      * instead of opening a second connection. One issued while a {@link disconnect} is closing
      * waits for that close first; one issued while an attempt that a {@link disconnect}
-     * superseded is still unwinding OUTWAITS it, because that attempt may still owe the close
+     * superseded is still unwinding outwaits it, because that attempt may still owe the close
      * of a connection it opened, and then opens the next connection or joins whichever caller
-     * reached it first. One issued while a close is still OWED — an earlier `close` having failed,
+     * reached it first. One issued while a close is still owed — an earlier `close` having failed,
      * or having outrun its deadline without ever confirming that the connection ended — closes that
-     * connection FIRST, joining a close still running rather than issuing a second one, and rejects
+     * connection first, joining a close still running rather than issuing a second one, and rejects
      * with the fault if that close fails or goes unanswered again; so the transport is never opened
      * beside a connection no path has closed. The client probes `server/discover`; an explicit legacy
      * transport adapter owns any `initialize` handshake and presents a modern discovery result.
@@ -2933,7 +2963,7 @@ export declare interface MCPClientInterface {
      * `start` does, because nothing here bounds the opening step. It closes the connection the
      * client owns when it runs, and closes nothing for an attempt still inside the transport's
      * `start` — that attempt owns nothing yet and closes what it opens itself. The transport's
-     * `close` carries the per-request deadline on the WAIT, so a shutdown the transport accepts and
+     * `close` carries the per-request deadline on the wait, so a shutdown the transport accepts and
      * never answers rejects instead of holding this caller and every later {@link connect} — while
      * that close itself keeps running, because the deadline only ends this client's waiting. A `close`
      * that faults or goes unanswered rejects this call and leaves the connection owned, so the next
@@ -2977,17 +3007,17 @@ export declare interface MCPClientInterface {
      *
      * @remarks
      * The answer is an {@link MCPCallOutcome} because the peer, not the caller, decides
-     * whether the call finished: a modern server may DEFER it into a durable task or ask
+     * whether the call finished: a modern server may defer it into a durable task or ask
      * for another round trip, and both are legal answers to an ordinary call. Narrow on
      * `resultType`; the `'complete'` arm carries the tool's `value` — the peer's
      * `structuredContent` when it sent one, otherwise its concatenated `text` parsed as
-     * JSON (falling back to the raw string). A remote tool FAILURE (`isError: true`)
-     * THROWS an `Error` carrying the error text instead, so an agent's
+     * JSON (falling back to the raw string). A remote tool failure (`isError: true`)
+     * throws an `Error` carrying the error text instead, so an agent's
      * {@link ToolManagerInterface} isolates it into a `success: false` result exactly as
      * it would a local tool throw. A `resultType` this client cannot name is refused.
      *
-     * `options.signal` cancels THIS request only — the caller stops waiting, the pending
-     * request rejects, and the peer is TOLD on a carrier that can carry a client
+     * `options.signal` cancels this request only — the caller stops waiting, the pending
+     * request rejects, and the peer is told on a carrier that can carry a client
      * notification (see {@link MCPMessageTransportInterface.duplex}). MCP cancellation is
      * advisory: the peer may answer anyway, and that late answer is discarded rather than
      * raised. `options.progress` receives this request's progress frames.
@@ -3006,7 +3036,7 @@ export declare interface MCPClientInterface {
  * `on` hooks.
  *
  * @remarks
- * - `transport` — the carrier the client drives a remote MCP server over (REQUIRED;
+ * - `transport` — the carrier the client drives a remote MCP server over (required;
  *   a concrete one from `src/server/mcp`, or an in-process loopback). The bare client negotiates
  *   the modern revision through `server/discover`; wrap the carrier with
  *   {@link import('./factories.js').createMCPLegacyClientTransport} for a legacy peer.
@@ -3017,9 +3047,9 @@ export declare interface MCPClientInterface {
  *   request; defaults to an empty record.
  * - `version` — an optional modern protocol pin; absence lets `server/discover` negotiate.
  * - `timeout` — the per-request deadline in milliseconds: a `server/discover` / `tools/list` /
- *   `tools/call` that the server does not answer within it REJECTS (the pending
+ *   `tools/call` that the server does not answer within it rejects (the pending
  *   request is settled by an `AbortSignal.timeout(timeout)` deadline — never a raw
- *   `setTimeout`). The same deadline bounds the client's WAIT on the transport's `close`, so a
+ *   `setTimeout`). The same deadline bounds the client's wait on the transport's `close`, so a
  *   shutdown the transport accepts and never answers rejects its caller instead of wedging the
  *   client — which makes a short `timeout` a short shutdown grace as well as a short request
  *   deadline. Defaults to {@link import('./constants.js').DEFAULT_MCP_REQUEST_TIMEOUT}.
@@ -3070,7 +3100,7 @@ export declare interface MCPCompletionContext {
  * verbatim and performs no template parsing or expansion. Returning `undefined` means the
  * referenced prompt or resource template does not exist.
  *
- * This is the PORT that produces a {@link MCPCompletion}, not the behavioural face of one: the
+ * This is the port that produces a {@link MCPCompletion}, not the behavioural face of one: the
  * candidate set is the data type, and this contract is the single method a host answers it from.
  */
 export declare interface MCPCompletionInterface {
@@ -3084,7 +3114,10 @@ export declare interface MCPCompletionInterface {
     complete(params: MCPCompletionParams, options: MCPMethodOptions): MCPCompletion | undefined | Promise<MCPCompletion | undefined>;
 }
 
-/** Parameters accepted by `completion/complete`. */
+/**
+ * Represents the parameters `completion/complete` accepts — a reference, the argument fragment
+ * being completed, and the optional resolved context.
+ */
 export declare interface MCPCompletionParams {
     readonly ref: MCPCompletionReference;
     readonly argument: MCPCompletionArgument;
@@ -3094,7 +3127,13 @@ export declare interface MCPCompletionParams {
 /** Represents the prompt or resource-template reference accepted by `completion/complete`. */
 export declare type MCPCompletionReference = MCPPromptReference | MCPResourceTemplateReference;
 
-/** Represents the complete `completion/complete` result. */
+/**
+ * Represents the complete `completion/complete` result.
+ *
+ * @remarks
+ * The candidate set is capped at 100 values, and `hasMore` reads `true` whenever that cap
+ * truncated the host's own answer.
+ */
 export declare interface MCPCompletionResult {
     readonly resultType: 'complete';
     readonly completion: MCPCompletion;
@@ -3174,7 +3213,7 @@ export declare interface MCPDispatcherInterface {
  * Represents the per-request execution options every dispatched handler receives.
  *
  * @remarks
- * `caller` is consumer-ASSERTED and NEVER VERIFIED. Sessions mint transport identity, not
+ * `caller` is consumer-ASSERTED and never verified. Sessions mint transport identity, not
  * caller identity, and nothing in MCP authenticates this value. This package carries it
  * opaquely without inspecting, validating, or serializing it. A consumer must narrow it with
  * its own total guard and treat absence as unauthenticated.
@@ -3277,7 +3316,12 @@ export declare interface MCPElicitSchema extends Readonly<Record<string, unknown
     readonly required?: readonly string[];
 }
 
-/** Represents the parameters of a URL-mode `elicitation/create` request. */
+/**
+ * Represents the parameters of a URL-mode `elicitation/create` request.
+ *
+ * @remarks
+ * A consumer round may compose one, and the client must declare `elicitation.url` to receive it.
+ */
 export declare interface MCPElicitURL {
     readonly mode: 'url';
     readonly message: string;
@@ -3449,10 +3493,10 @@ export declare interface MCPInputOptions {
  * Represents one embedded multi-round-trip request.
  *
  * @remarks
- * A consumer composes any of the three arms into an {@link MCPInputRound}, and this server
+ * A consumer composes any of the arms into an {@link MCPInputRound}, and this server
  * issues whichever arms that round carries. The elicitation arm is fully typed because this
  * package issues its schema and enforces the answer against it. The sampling and roots arms
- * keep OPEN parameter records: the dated schema leaves their request bodies to the caller, and
+ * keep open parameter records: the dated schema leaves their request bodies to the caller, and
  * narrowing them here would refuse parameters the protocol permits.
  */
 export declare type MCPInputRequest = MCPElicitRequest | {
@@ -3473,7 +3517,7 @@ export declare type MCPInputRequestMap = Readonly<Record<string, MCPInputRequest
  * The arms are discriminated by their own required members — `action` for an elicitation,
  * `roots` for a roots listing, and `model` beside `role` for a sampling completion — because
  * the protocol gives a response no `method` of its own. The server knows which arm applies
- * from the request it ISSUED under that key, so {@link MCPInputHandler} receives every answer
+ * from the request it issued under that key, so {@link MCPInputHandler} receives every answer
  * already checked against the question it answers.
  */
 export declare type MCPInputResponse = MCPElicitResult | MCPSampleResult | MCPRootResult;
@@ -3520,9 +3564,9 @@ export declare interface MCPInputRound {
  * Represents the integrity-protected payload carried inside an opaque `requestState` token.
  *
  * @remarks
- * `id` is the FIRST round's request id and stays bound across every later round, so a
+ * `id` is the first round's request id and stays bound across every later round, so a
  * multi-round exchange remains one correlated call rather than a chain whose origin is lost
- * after the second hop. `requests` is the EXACT round that was issued: it carries the keys the
+ * after the second hop. `requests` is the exact round that was issued: it carries the keys the
  * retry must answer and, for a form elicitation, the schema {@link isElicitContent} enforces
  * an accepted answer against — a round that is bound but never enforced buys nothing.
  * `requests` and `expiry` are re-minted every round; `principal`, `id`, `version`, `method`,
@@ -3657,7 +3701,7 @@ export declare interface MCPLegacyOptions {
  *
  * @remarks
  * The legacy revision has no result-discriminator concept, so a legacy result
- * carries NO `resultType`. That absence is the whole distinction, which is why it is
+ * carries no `resultType`. That absence is the whole distinction, which is why it is
  * declared `never` rather than optional: an {@link MCPResult} is not assignable
  * here, this type is not assignable to {@link MCPResult}, and
  * `result.resultType === undefined` narrows a {@link JSONRPCResultResponse}'s
@@ -3728,13 +3772,13 @@ export declare type MCPLoggingLevel = 'debug' | 'info' | 'notice' | 'warning' |
  * {@link MCPClientInterface} (and any tracer) subscribes to through `transport.emitter.on`.
  *
  * @remarks
- * - `message` — a JSON-RPC message ARRIVED from the remote server (a response the
+ * - `message` — a JSON-RPC message arrived from the remote server (a response the
  *   client correlates to a pending request by `id`, or a server-initiated
  *   notification). The transport decodes the wire bytes (a JSON body or an SSE
  *   `data:` event) and emits the parsed {@link JSONRPCMessage}.
  * - `close` — the transport's connection ended (a stream closed, `close()` ran).
  * - `error` — a transport-level fault (a malformed message, a network error); the
- *   payload is typed `unknown`. This is a DOMAIN event, distinct from the emitter's
+ *   payload is typed `unknown`. This is a domain event, distinct from the emitter's
  *   own listener-error channel: a listener throw is routed to the emitter's `error` handler
  *   (the `error` option), never onto this map. Declared as a `type` alias so the
  *   type-literal satisfies `EventMap` structurally.
@@ -3768,7 +3812,7 @@ export declare interface MCPMessageTransportInterface {
     /** Holds a server-assigned session id after a stateful transport has one; `undefined` otherwise. */
     readonly session: string | undefined;
     /**
-     * Reports whether this carrier accepts a CLIENT-INITIATED notification — one written with
+     * Reports whether this carrier accepts a client-initiated notification — one written with
      * no `id`, which no response will ever answer.
      *
      * @remarks
@@ -3779,7 +3823,7 @@ export declare interface MCPMessageTransportInterface {
      * `true` for a genuinely bidirectional channel — a WebSocket, a stdio pipe pair, an
      * in-process duplex port — where a frame the client writes at any moment reaches the
      * peer. `false` for a request/response carrier such as Streamable HTTP: the dated
-     * revision defines NO client-to-server notification over it, and the cancellation
+     * revision defines no client-to-server notification over it, and the cancellation
      * signal there is closing the response stream rather than a frame. A `false` carrier
      * is not a degraded one — it has its own signal — so the client withholds the frame
      * rather than writing one nothing will read.
@@ -3789,7 +3833,7 @@ export declare interface MCPMessageTransportInterface {
      * Opens the transport — establishes the connection and arms any reply reader.
      *
      * @remarks
-     * A `start` that REJECTS must first release whatever it had already acquired. The
+     * A `start` that rejects must first release whatever it had already acquired. The
      * {@link MCPClientInterface} claims a connection only once `start` resolves, so a rejection
      * leaves it holding an error and no claim: a socket, session, or reader the transport opened
      * before failing is reachable by nothing the client can call, and no client-side mechanism can
@@ -3807,7 +3851,7 @@ export declare interface MCPMessageTransportInterface {
      * transport, its synchronous reply emitted), not when a logical response arrives;
      * the {@link MCPClientInterface} awaits the response through its `id` correlation.
      *
-     * A `send` that FAILS must fail by REJECTING, never by throwing synchronously. The
+     * A `send` that fails must fail by rejecting, never by throwing synchronously. The
      * {@link MCPClientInterface} registers the write inside the same promise executor that
      * records the request's pending entry, so a synchronous throw leaves no promise for that
      * registration to attach to: the entry set one statement earlier is never settled, and a
@@ -3831,18 +3875,18 @@ export declare interface MCPMessageTransportInterface {
      * Closes the transport — ends the connection and releases resources.
      *
      * @remarks
-     * A `close` must SETTLE, and its settlements mean different things to its caller: resolving
+     * A `close` must settle, and its settlements mean different things to its caller: resolving
      * says the connection ended, rejecting says it did not. The
      * {@link MCPClientInterface}'s only other bound is a deadline, which reports that the shutdown
-     * did not ANSWER and never that it did not happen — so a `close` that resolves or rejects hours
+     * did not answer and never that it did not happen — so a `close` that resolves or rejects hours
      * late still decides the outcome, and one that never settles leaves the connection owed for the
      * client's life. `close` is never called twice concurrently for one connection: a caller that
-     * gave up waiting JOINS the `close` still running rather than issuing another. It IS called
-     * again after an earlier `close` REJECTED, because a rejected close ended nothing.
+     * gave up waiting joins the `close` still running rather than issuing another. It is called
+     * again after an earlier `close` rejected, because a rejected close ended nothing.
      *
-     * `close` is IDEMPOTENT: a call on a transport an earlier `close` already ended resolves
+     * `close` is idempotent: a call on a transport an earlier `close` already ended resolves
      * without emitting `close` again and without releasing anything a second time. Idempotence
-     * bounds ONE closed lifetime rather than the object — a transport that reopens on `start`
+     * bounds one closed lifetime rather than the object — a transport that reopens on `start`
      * arms itself there, and its next `close` ends that connection and emits once for it.
      *
      * @returns Resolves once the transport is closed
@@ -3854,7 +3898,7 @@ export declare interface MCPMessageTransportInterface {
  * Represents the exact finite JSON metadata carried by MCP `_meta` envelopes.
  *
  * @remarks
- * The `Object` suffix is not a role suffix from the type table — it NAMES THE SHAPE.
+ * The `Object` suffix is not a role suffix from the type table — it names the shape.
  * `_meta` is a JSON object whose values are exact JSON, and a reader who sees
  * `MCPMeta` cannot tell that from a key, a string, or an entry. The same holds for
  * {@link MCPResultMetaObject} and {@link MCPSubscriptionResultMetaObject}, which are
@@ -3868,21 +3912,21 @@ export declare type MCPMetaObject = Readonly<Record<string, JSONValue>>;
  * @remarks
  * A registered method answers a {@link JSONRPCRequest} — with a terminating
  * {@link JSONRPCResponse}, or by holding the exchange open as an {@link MCPStream}. It is
- * invoked for nothing else: dispatch short-circuits a {@link JSONRPCNotification} BEFORE the
+ * invoked for nothing else: dispatch short-circuits a {@link JSONRPCNotification} before the
  * registry is read, so the notification arm never arrives here and no handler has to narrow
  * one away.
  *
  * The seam is this narrow because the future a wider one was kept for is structurally
  * unavailable. The only client-to-server notification the core protocol defines is
- * `notifications/cancelled`, and a handler acting on one must reach the OTHER request's
- * `AbortController` — which dispatch creates per request, AFTER the notification
+ * `notifications/cancelled`, and a handler acting on one must reach the other request's
+ * `AbortController` — which dispatch creates per request, after the notification
  * short-circuit, and publishes to no registry and no member. Admitting a cancellation
  * handler therefore needs a live request-id-to-controller registry — new cross-request
  * server state — before the parameter's width ever becomes the obstacle.
  *
  * Answering is not optional either, and that is a runtime rule as well as a type. A handler
  * resolving `undefined` for a request contradicts `dispatch`'s own overloads and leaves the
- * caller waiting until its deadline, so dispatch CONTAINS one as `-32603` plus a single
+ * caller waiting until its deadline, so dispatch contains one as `-32603` plus a single
  * `error` event rather than passing the absence on.
  *
  * `options.signal` is already resolved and always present — what a handler does with it
@@ -3902,10 +3946,10 @@ export declare type MCPMethodHandler = (request: JSONRPCRequest, options: MCPMet
  *
  * @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.
@@ -3926,12 +3970,12 @@ export declare class MCPMethodManager implements MCPMethodManagerInterface {
 
 /**
  * Represents the modern method registry an {@link MCPServerInterface} dispatches through —
- * the ONE seam carrying both the built-in methods and any method a consumer adds.
+ * the one seam carrying both the built-in methods and any method a consumer adds.
  *
  * @remarks
  * `server/discover`, `tools/list`, `tools/call`, and `subscriptions/listen` are registered here at construction,
- * so they travel the SAME path as every later method: there is no second dispatch route
- * and no precedence puzzle. `add` under an existing name REPLACES that method — a
+ * so they travel the same path as every later method: there is no second dispatch route
+ * and no precedence puzzle. `add` under an existing name replaces that method — a
  * consumer overriding a built-in is an ordinary registration, not a special case. A name
  * with no handler is not an error state to model: {@link method} answers `undefined` and
  * the dispatch branch turns that into `-32601`.
@@ -3954,12 +3998,12 @@ export declare interface MCPMethodManagerInterface {
 }
 
 /**
- * Represents the RESOLVED per-request options one dispatched method receives.
+ * Represents the resolved per-request options one dispatched method receives.
  *
  * @remarks
- * The mirror of {@link MCPDispatchOptions} on the far side of dispatch: a CALLER may
+ * The mirror of {@link MCPDispatchOptions} on the far side of dispatch: a caller may
  * have no signal to offer, but a dispatched method always has one to observe, so
- * `signal` is REQUIRED here. Dispatch resolves it once, at the single ingress, and
+ * `signal` is required here. Dispatch resolves it once, at the single ingress, and
  * supplies the same value to every handler, input, principal, and subscription
  * producer the request reaches — none of them may reinvent a cancellation source or
  * treat absence as a case.
@@ -3967,14 +4011,14 @@ export declare interface MCPMethodManagerInterface {
  * Distinct from {@link MCPExecutionContext}, which is scoped to one tool execution
  * and carries the call and registry alongside the signal.
  *
- * The resolved signal is the request's LIFETIME, not merely the caller's: it aborts when
- * the caller's own signal aborts AND when the answer this request produced is finished —
+ * The resolved signal is the request's lifetime, not merely the caller's: it aborts when
+ * the caller's own signal aborts and when the answer this request produced is finished —
  * a held-open stream that completed, that its consumer returned, or that an owner stopped.
  * A producer parked on an event that will never arrive is woken by exactly that, which is
  * why a custom stream producer observes this signal for its own cleanup instead of
  * relying on the consumer to iterate it to the end.
  *
- * `caller` is consumer-ASSERTED and NEVER VERIFIED, and is carried by identity: this
+ * `caller` is consumer-ASSERTED and never verified, and is carried by identity: this
  * package neither inspects, validates, clones, nor serializes it.
  */
 export declare interface MCPMethodOptions {
@@ -3991,13 +4035,13 @@ export declare type MCPModernVersion = '2026-07-28';
  * Carries open notification metadata with the dated reserved subscription field.
  *
  * @remarks
- * The subscription id is OPTIONAL here, and that is the schema's own split rather than
+ * The subscription id is optional here, and that is the schema's own split rather than
  * this package hedging. A frame delivered down a `subscriptions/listen` stream carries the
  * stamp naming the listen request that agreed to it; the same notification delivered any
  * other way carries no stamp, because there is no subscription to name. A required key
  * would refuse a frame the protocol permits.
  *
- * Compare {@link MCPSubscriptionResultMetaObject}, where the same key is REQUIRED: that one
+ * Compare {@link MCPSubscriptionResultMetaObject}, where the same key is required: that one
  * sits on the terminating result of a stream, so a subscription always exists to name.
  */
 export declare type MCPNotificationMetaObject = MCPMetaObject & {
@@ -4007,13 +4051,23 @@ export declare type MCPNotificationMetaObject = MCPMetaObject & {
     readonly 'io.modelcontextprotocol/subscriptionId'?: JSONRPCId;
 };
 
-/** Represents the cursor parameters shared by every paginated modern list method. */
+/**
+ * Represents the cursor parameters shared by every paginated modern list method.
+ *
+ * @remarks
+ * The cursor is opaque to this package, and the consumer's own manager mints it.
+ */
 export declare interface MCPPaginationParams {
     /** Holds the opaque cursor returned by the preceding page. */
     readonly cursor?: string;
 }
 
-/** Represents the cursor result fields shared by every paginated modern list method. */
+/**
+ * Represents the cursor result fields shared by every paginated modern list method.
+ *
+ * @remarks
+ * An absent `nextCursor` member means the answered page was the final one.
+ */
 export declare interface MCPPaginationResult {
     /** Holds the opaque cursor for the following page; absent when this is the final page. */
     readonly nextCursor?: string;
@@ -4039,14 +4093,14 @@ export declare interface MCPProgress {
  * Receives one progress report a peer published for a request this client issued.
  *
  * @remarks
- * The RECEIVING half of {@link MCPProgressInterface}, and deliberately not its mirror:
+ * The receiving half of {@link MCPProgressInterface}, and deliberately not its mirror:
  * the reporter awaits consumption because a server must not outrun the stream carrying
  * its frames, while a client consuming an already-delivered frame has nothing left to
  * push back on. So this returns `void` — a handler that throws is isolated by nothing
  * and would surface on the client's `error` event, and one that needs to await
  * something owns that lifetime itself.
  *
- * The handler is registered for the LIFETIME OF ONE REQUEST and is released the moment
+ * The handler is registered for the lifetime of one request and is released the moment
  * that request settles, whichever way it settles. A frame that arrives afterwards is a
  * late frame for a request nobody is waiting on, and reaches the `notification` event
  * like any other unclaimed server-initiated message.
@@ -4063,12 +4117,12 @@ export declare interface MCPProgressInterface {
 }
 
 /**
- * Represents the OWNING half of one progress slot — {@link MCPProgressInterface} plus the
+ * Represents the owning half of one progress slot — {@link MCPProgressInterface} plus the
  * consuming and stopping the slot's owner performs.
  *
  * @remarks
- * Two interfaces over one entity because two parties hold it and they are owed different
- * powers. An executor receives the narrow {@link MCPProgressInterface} through
+ * A second interface over one entity because the executor and the owner hold it and they are
+ * owed different powers. An executor receives the narrow {@link MCPProgressInterface} through
  * {@link MCPExecutionContext} and can publish and nothing else; the MCP-owned response stream
  * that created the slot holds this one and also drains it and shuts it down. Naming the owner's
  * half is what keeps `take` and `stop` documented as contract rather than as extra surface a
@@ -4165,7 +4219,13 @@ export declare interface MCPPromptArgument {
     readonly required?: boolean;
 }
 
-/** Parameters accepted by `prompts/get`. */
+/**
+ * Represents the parameters `prompts/get` accepts — a prompt name plus the optional argument
+ * values and multi-round continuation carriers.
+ *
+ * @remarks
+ * Argument values are strings by contract, which is what the prompt wire shape requires.
+ */
 export declare interface MCPPromptGetParams {
     readonly name: string;
     readonly arguments?: Readonly<Record<string, string>>;
@@ -4258,8 +4318,8 @@ export declare interface MCPRequestContext {
  * correlated-request path here, so a task read travels the exact channel `call` and `tools`
  * travel — one id space, one pending table, one drain on `disconnect`.
  *
- * It resolves the peer's `result` UNVALIDATED, because validating it is the caller's job and
- * every caller wants a different shape. It REJECTS with an
+ * It resolves the peer's `result` unvalidated, because validating it is the caller's job and
+ * every caller wants a different shape. It rejects with an
  * {@link import('./errors.js').MCPError} for an error response, and with an ordinary `Error`
  * for a deadline, an abort, or a transport write that failed.
  *
@@ -4322,8 +4382,8 @@ export declare type MCPResourceListResult = MCPResourcePage & {
  * Represents the consumer-supplied resource registry port.
  *
  * @remarks
- * MCP owns no storage. The host may back this port with memory, a workspace, a database,
- * or any other registry. The list methods carry the shared cursor contract verbatim;
+ * MCP owns no storage and no template engine. The host may back this port with memory, a
+ * workspace, a database, or any other registry. The list methods carry the shared cursor contract verbatim;
  * `resource` returns `undefined` when the URI does not resolve and may instead return an
  * {@link MCPInputResult} for a modern multi-round interaction.
  */
@@ -4363,7 +4423,10 @@ export declare interface MCPResourcePage extends MCPPaginationResult {
     readonly resources: readonly MCPResource[];
 }
 
-/** Parameters accepted by `resources/read`. */
+/**
+ * Represents the parameters `resources/read` accepts — a concrete `uri` plus the optional
+ * multi-round continuation carriers.
+ */
 export declare interface MCPResourceReadParams {
     readonly uri: string;
     readonly inputResponses?: Readonly<Record<string, unknown>>;
@@ -4379,7 +4442,13 @@ export declare type MCPResourceReadResult = {
     readonly _meta?: MCPResultMetaObject;
 };
 
-/** Represents one RFC 6570 resource-template descriptor advertised by `resources/templates/list`. */
+/**
+ * Represents one RFC 6570 resource-template descriptor advertised by `resources/templates/list`.
+ *
+ * @remarks
+ * The `uriTemplate` member is published as a string and forwarded verbatim: this package never
+ * parses or expands it, and no RFC 6570 level is implied.
+ */
 export declare interface MCPResourceTemplate {
     readonly uriTemplate: string;
     readonly name: string;
@@ -4404,7 +4473,12 @@ export declare interface MCPResourceTemplatePage extends MCPPaginationResult {
     readonly resourceTemplates: readonly MCPResourceTemplate[];
 }
 
-/** Represents a completion reference to one resource-template URI descriptor. */
+/**
+ * Represents a completion reference to one resource-template URI descriptor.
+ *
+ * @remarks
+ * The `uri` member may itself be a template, and it is forwarded to the host verbatim.
+ */
 export declare interface MCPResourceTemplateReference {
     readonly type: 'ref/resource';
     readonly uri: string;
@@ -4414,7 +4488,7 @@ export declare interface MCPResourceTemplateReference {
  * Represents one modern MCP result — the open contract every dated-revision result satisfies.
  *
  * @remarks
- * The dated schema requires a `resultType` on EVERY modern result and leaves the
+ * The dated schema requires a `resultType` on every modern result and leaves the
  * rest of the object open, so this contract does the same: `resultType` is a string
  * rather than a closed union because the protocol keeps issuing new ones (`task`
  * alongside `complete` and `input_required`), and the index signature is the
@@ -4423,7 +4497,7 @@ export declare interface MCPResourceTemplateReference {
  * Concrete results — {@link MCPCallResult}, {@link MCPDiscoverResult},
  * {@link MCPListResult}, {@link MCPPromptListResult}, {@link MCPPromptGetResult},
  * {@link MCPCompletionResult}, {@link MCPInputResult}, and
- * {@link MCPSubscriptionResult} — stay CLOSED and keep their literal
+ * {@link MCPSubscriptionResult} — stay closed and keep their literal
  * `resultType`, so a caller that knows which method it called still narrows to a
  * literal through that result's guard. Openness lives here, at the arm a server may
  * answer any registered method through, and nowhere else.
@@ -4464,7 +4538,7 @@ export declare interface MCPRootResult {
  *
  * @remarks
  * The dated schema's `SamplingMessageContentBlock`: the text, image, and audio blocks
- * {@link MCPContent} also admits, plus the two tool blocks a tool-using model produces. The
+ * {@link MCPContent} also admits, plus the tool blocks a tool-using model produces. The
  * resource arms of {@link MCPContent} are deliberately absent — the schema leaves them out of
  * a sampling completion.
  */
@@ -4490,7 +4564,7 @@ export declare interface MCPSampleResult {
 }
 
 /**
- * Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with NO
+ * Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with no
  * transport coupling.
  *
  * @remarks
@@ -4500,7 +4574,7 @@ export declare interface MCPSampleResult {
  *   `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
@@ -4561,8 +4635,8 @@ export declare type MCPServerCapabilities = Readonly<Record<string, MCPMetaObjec
  * through `server.emitter.on`.
  *
  * @remarks
- * `request` fires at the TOP of every `dispatch` with the method, correlating id
- * (ABSENT for a notification, which has none), and structurally selected wire era, BEFORE the
+ * `request` fires at the top of every `dispatch` with the method, correlating id
+ * (absent for a notification, which has none), and structurally selected wire era, before the
  * method runs — so an observer sees every inbound call. Listener isolation is the emitter's: a
  * listener throw is routed to the emitter's `error` handler (the `error` option),
  * never onto this map, so a buggy observer can never corrupt a dispatch. Declared as
@@ -4577,14 +4651,14 @@ export declare type MCPServerEventMap = {
      * Fires ahead of the `_meta` bound check, so an observer sees a call the server is about
      * to refuse for exceeding its metadata budget exactly as it sees one that passes — an
      * observation surface that skipped the refused calls could not be used to account for
-     * inbound traffic. Only SCALARS are reported: nothing read out of the request graph
+     * inbound traffic. Only scalars are reported: nothing read out of the request graph
      * escapes here, so a listener can never observe a value the ownership seam has not yet
      * bounded.
      *
      * Not every reported invocation arrived from a peer. A modern `tools/call` reaching the
-     * HTTP POST handler (`createMCPPostHandler`) reports the SYNTHETIC `tools/list` that
+     * HTTP POST handler (`createMCPPostHandler`) reports the synthetic `tools/list` that
      * handler dispatches to read the called tool's `x-mcp-header` annotations, ahead of the
-     * call itself. Each carries the RESERVED id `0`, and one fires per page the handler
+     * call itself. Each carries the reserved id `0`, and one fires per page the handler
      * walks, up to {@link MCP_LOOKUP_PAGES}. So an observer accounting for inbound traffic
      * subtracts a `('tools/list', 0, 'modern')` that precedes a `tools/call`, and one
      * tracing the server's own work keeps it. The id is reserved by convention rather than
@@ -4592,7 +4666,7 @@ export declare type MCPServerEventMap = {
      */
     readonly request: readonly [method: string, id: JSONRPCId | undefined, era: MCPEra];
     /**
-     * Reports an operational fault the server CONTAINED — the caught value, exactly once per
+     * Reports an operational fault the server contained — the caught value, exactly once per
      * fault.
      *
      * @remarks
@@ -4602,11 +4676,11 @@ export declare type MCPServerEventMap = {
      * fault surfaced while a bound {@link MCPTransportInterface} was piping a reply out (a
      * `send` throw or rejection from `bindServer`).
      *
-     * This is the ONE place a caught detail is legible. The wire answer is detail-free by
-     * construction, so an operator who wants to know WHY a request failed subscribes here;
+     * This is the one place a caught detail is legible. The wire answer is detail-free by
+     * construction, so an operator who wants to know why a request failed subscribes here;
      * a peer never learns it. Payload typed `unknown` because a thrown value is.
      *
-     * A DOMAIN event, distinct from the emitter's own listener-error channel: a listener
+     * A domain event, distinct from the emitter's own listener-error channel: a listener
      * that throws while observing this event is routed to the emitter's `error` handler
      * (the `error` option) and never back onto this map.
      */
@@ -4615,21 +4689,21 @@ export declare type MCPServerEventMap = {
 
 /**
  * Dispatches JSON-RPC 2.0 modern requests over a live
- * {@link ToolManagerInterface}, with NO transport coupling (a transport layer
+ * {@link ToolManagerInterface}, with no transport coupling (a transport layer
  * pumps strings through `handle`).
  *
  * @remarks
- * - **`dispatch` and `handle`.** `dispatch(invocation)` is the TYPED core: it takes an
+ * - **`dispatch` and `handle`.** `dispatch(invocation)` is the typed core: it takes an
  *   already-parsed {@link JSONRPCInvocation}, runs the method, and resolves a
  *   {@link JSONRPCResponse} — or an {@link MCPStream} for a held-open modern method — for
  *   a {@link JSONRPCRequest}, and `undefined` for a {@link JSONRPCNotification}. Its
  *   overloads say exactly that, so a caller dispatching a request never handles an
  *   `undefined` answer and a caller dispatching a notification never handles a response.
- *   `handle(message)` is the STRING boundary: it `JSON.parse`s the raw message, narrows it
+ *   `handle(message)` is the string boundary: it `JSON.parse`s the raw message, narrows it
  *   to an invocation, dispatches, and serializes the answer back to a string (or an
  *   {@link MCPTextStream}, the same sequence already serialized) — turning a parse failure
  *   into a `-32700` response and a non-invocation into a `-32600` response, and returning
- *   `undefined` for a notification. Both error envelopes OMIT the `id` they could not read.
+ *   `undefined` for a notification. Both error envelopes omit the `id` they could not read.
  * - **One method seam.** Every modern method — the built-in `server/discover` /
  *   `tools/list` / `tools/call` / `subscriptions/listen` and configured resource methods
  *   included — is registered on `methods` and dispatched
@@ -4651,7 +4725,7 @@ export declare interface MCPServerInterface extends MCPDispatcherInterface {
      * @remarks
      * Derived from {@link MCPServerOptions.limit} at construction and stored nowhere else, so
      * it cannot drift from the value the boundary checks read. It is published because the
-     * code in front of the server needs the SAME number: a binder that decodes an inbound
+     * code in front of the server needs the same number: a binder that decodes an inbound
      * message before handing it on must refuse at the byte the server would have refused at,
      * and the alternative — a second configured copy of one bound, on the binder's own options
      * — is a second number that will disagree the first time either is changed.
@@ -4661,11 +4735,11 @@ export declare interface MCPServerInterface extends MCPDispatcherInterface {
      * Dispatches an already-parsed request — runs its method and resolves its answer.
      *
      * @remarks
-     * A held-open modern method answers with a CONTROLLED stream instead of a response:
+     * A held-open modern method answers with a controlled stream instead of a response:
      * narrow a stream from a response with `Symbol.asyncIterator in answer`. Whatever the method
      * produced, what leaves here is an {@link MCPStreamControllerInterface} — dispatch is
      * the one wrapping seam — so a caller may end the exchange promptly without waiting on
-     * the producer. `options` is optional, so a caller that cannot abort simply never
+     * the producer. `options` is optional, so a caller that cannot abort never
      * supplies one; dispatch resolves the signal every method observes.
      *
      * @param request - The parsed JSON-RPC request to dispatch
@@ -4687,7 +4761,7 @@ export declare interface MCPServerInterface extends MCPDispatcherInterface {
      * @remarks
      * The union arm a transport uses when it has narrowed a message no further than
      * {@link JSONRPCInvocation}. A value that is not structurally an invocation at
-     * RUNTIME — which only a caller defeating these types can produce — answers a
+     * runtime — which only a caller defeating these types can produce — answers a
      * `-32600` error response with no `id`.
      *
      * @param invocation - The parsed JSON-RPC invocation to dispatch
@@ -4701,13 +4775,13 @@ export declare interface MCPServerInterface extends MCPDispatcherInterface {
      * @remarks
      * A `JSON.parse` failure resolves a serialized `-32700` (Parse error) response;
      * a parsed value that is not a valid invocation resolves a serialized `-32600`
-     * (Invalid Request) response — each with its unreadable `id` OMITTED, never `null`;
+     * (Invalid Request) response — each with its unreadable `id` omitted, never `null`;
      * a notification resolves `undefined` (no response). A
      * held-open method resolves an {@link MCPTextStreamControllerInterface} — the controlled
      * typed stream's mirror, already serialized — so a transport writes each message with no
      * second parse and can still end the exchange it is writing.
      *
-     * The vague-verb prohibition (`process`, `handle`) governs STANDALONE helpers,
+     * The vague-verb prohibition (`process`, `handle`) governs standalone helpers,
      * which carry no entity to supply their object. Here the entity does: `server.handle`
      * reads as "the server handles this message", and it is the string-boundary twin of
      * {@link dispatch} — one verb per entry point, the same act at the typed and string levels.
@@ -4766,7 +4840,7 @@ export declare interface MCPServerOptions {
      * Holds the optional explicit execution policy above the canonical live tool registry.
      *
      * @remarks
-     * This is also the ONLY way a tool observes cancellation. The default path calls
+     * This is also the only way a tool observes cancellation. The default path calls
      * {@link ToolManagerInterface.execute}, whose signature takes a call and nothing else, so
      * there is no seam to hand a signal through — a server with no `execution` runs its tool to
      * completion even after the request that asked for it has ended, and abandons the result.
@@ -4799,7 +4873,7 @@ export declare interface MCPServerOptions {
      *
      * @remarks
      * Omitting it leaves every existing path untouched — nothing is advertised, no call is
-     * deferred, and `tasks/*` stays unregistered. The extension is the STABLE, immutable
+     * deferred, and `tasks/*` stays unregistered. The extension is the stable, immutable
      * snapshot dated 2026-07-28, so the shape this option admits is fixed.
      */
     readonly task?: MCPTaskOptions;
@@ -4812,14 +4886,14 @@ export declare interface MCPServerOptions {
  * `return` value is the terminating response.
  *
  * @remarks
- * A stream yields NOTIFICATIONS and never requests — the yield type forbids an `id`,
+ * A stream yields notifications and never requests — the yield type forbids an `id`,
  * so a producer cannot put a call the peer is expected to answer onto a stream that
  * has no way to carry the answer back.
  *
- * Held-open closure is a RESULT in the modern revision, not an out-of-band event, so it
+ * Held-open closure is a result in the modern revision, not an out-of-band event, so it
  * arrives where a result arrives — the generator's `return`. Consuming a stream and
  * consuming a unary response therefore end the same way, and a transport narrows a stream
- * from a response at ONE point (`Symbol.asyncIterator in answer`), at the place that already pumps
+ * from a response at one point (`Symbol.asyncIterator in answer`), at the place that already pumps
  * messages onto the wire. The `TNext` type parameter is stated explicitly because a stream
  * accepts nothing back from its consumer.
  */
@@ -4830,16 +4904,16 @@ export declare type MCPStream = AsyncGenerator<JSONRPCNotification, JSONRPCRespo
  * 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.
  *
@@ -4847,7 +4921,7 @@ export declare type MCPStream = AsyncGenerator<JSONRPCNotification, JSONRPCRespo
  * 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,
@@ -4933,28 +5007,28 @@ export declare class MCPStreamController implements MCPStreamControllerInterface
 }
 
 /**
- * Represents a held-open modern result whose cancellation ONE owner arbitrates — the arm
+ * Represents a held-open modern result whose cancellation one owner arbitrates — the arm
  * every stream leaving `MCPServer.dispatch` takes.
  *
  * @remarks
  * The generator protocol states what a stream yields and says nothing about who ends one,
- * and a native async generator answers that badly: `return()` and `throw()` QUEUE behind a
+ * and a native async generator answers that badly: `return()` and `throw()` queue behind a
  * `next()` the producer has not answered yet, so a consumer walking away from a source
  * parked on an event that will never arrive waits forever for its own cancellation. A
- * controller settles the consumer's read ITSELF, aborts the request's signal before it
+ * controller settles the consumer's read itself, aborts the request's signal before it
  * delegates cleanup to the producer, contains every promise the producer settles late, and
  * makes every closure path idempotent.
  *
- * {@link stop} is the operation the protocol has no member for: end the exchange with NO
+ * {@link stop} is the operation the protocol has no member for: end the exchange with no
  * terminal, from an owner that is not the consumer of the iteration — a transport whose
  * connection closed, a pump whose write failed. `return(value)` says "here is the answer";
  * `stop()` says "there will be no answer", and that is exactly the difference a cancelled
  * request and a completed one must not blur.
  *
- * **Ending a controlled exchange is the obligation of whoever is handed it, on EVERY exit —
+ * **Ending a controlled exchange is the obligation of whoever is handed it, on every exit —
  * including the exits where nothing was cancelled.** One of these holds a producer, a request
  * lifetime, and (for the built-in `subscriptions/listen`) one of a finite number of live
- * server slots, and a consumer that simply walks away releases none of them: no signal fires
+ * server slots, and a consumer that walks away releases none of them: no signal fires
  * when nobody aborts anything. So an owner releases through {@link stop} or
  * {@link MCPStreamControllerInterface.[Symbol.asyncDispose] | asyncDispose} on the normal
  * return, on a mid-loop throw, and on a transport that closed underneath the pump alike —
@@ -4962,10 +5036,10 @@ export declare class MCPStreamController implements MCPStreamControllerInterface
  * floor, is for.
  *
  * A conforming {@link MCPStreamControllerInterface.[Symbol.asyncDispose] | asyncDispose}
- * releases the producer, request lifetime, and live slot BEFORE it may reject. Throwing before
+ * releases the producer, request lifetime, and live slot before it may reject. Throwing before
  * release would let a disposal fault mask the pump's original failure while leaking the exchange.
  *
- * There is deliberately NO owner of last resort — no finalizer, no timer, no timeout. One
+ * There is deliberately no owner of last resort — no finalizer, no timer, no timeout. One
  * would convert a missing obligation into a nondeterministic one and hide the very defect
  * this sentence exists to make visible, and GC timing is not a lifecycle.
  */
@@ -4974,7 +5048,7 @@ export declare interface MCPStreamControllerInterface extends MCPStream {
      * Reads the next notification, or the terminating response that ends the exchange.
      *
      * @remarks
-     * At most ONE read is outstanding against the producer, and a rival read is refused
+     * At most one read is outstanding against the producer, and a rival read is refused
      * rather than queued: two live consumers on one held-open answer would split a sequence
      * neither could reassemble. A read parked on the producer settles the moment the exchange
      * closes, however long the producer takes to notice.
@@ -5026,11 +5100,11 @@ export declare interface MCPStreamControllerInterface extends MCPStream {
  * Names the notification families a client may opt in to on a `subscriptions/listen` stream.
  *
  * @remarks
- * Every key here is a WIRE SPELLING, carried verbatim from the dated schema's
+ * Every key here is a wire spelling, carried verbatim from the dated schema's
  * `params.notifications` object. They are the one place in this file where the
  * compound-key prohibition does not apply, because these strings are not this
  * package's to choose: grouping them into `{ tools: { changed } }` would read better
- * and would speak a protocol no peer implements. The type NAME is the library's own
+ * and would speak a protocol no peer implements. The type name is the library's own
  * and takes the `MCP` prefix; the keys are the protocol's and do not change.
  */
 export declare interface MCPSubscriptionFilter {
@@ -5047,17 +5121,17 @@ export declare interface MCPSubscriptionFilter {
      *
      * @remarks
      * The wire placement is `params.notifications.taskIds`, beside `resourceSubscriptions`,
-     * and that placement is THIS PACKAGE'S READING rather than a settled fact: the Tasks
+     * and that placement is this package's reading rather than a settled fact: the Tasks
      * extension declares the fragment carrying this member without composing it into the
      * `subscriptions/listen` request, so no source states where the fragment lands. The
      * spelling itself is the schema's and is carried verbatim under the same wire-key
      * exemption as its siblings.
      *
-     * The server honours the member only when a consumer configured BOTH a task manager and
+     * The server honours the member only when a consumer configured both a task manager and
      * a subscription producer: the manager resolves each requested identifier before the
      * acknowledgement agrees to it, and the producer is what a transition frame arrives
      * through. Either one missing leaves nothing to deliver, so the acknowledgement omits
-     * the member. That fact is DERIVED from the two configured options at the moment the
+     * the member. That fact is derived from the configured options at the moment the
      * listen request is answered; no third flag records it, so it cannot drift from them.
      */
     readonly taskIds?: readonly string[];
@@ -5108,14 +5182,14 @@ export declare type MCPSubscriptionStream = AsyncGenerator<JSONRPCNotification,
  * with.
  *
  * @remarks
- * Every field name here is a WIRE SPELLING carried verbatim from the extension's
- * schema, so the compound-member prohibition does not reach them; the type NAME is
+ * Every field name here is a wire spelling carried verbatim from the extension's
+ * schema, so the compound-member prohibition does not reach them; the type name is
  * this library's own. `ttlMs` is `null` — not absent — when the task has no expiry,
  * because the schema distinguishes absence from `null`. `createdAt` and `lastUpdatedAt` are
  * described as ISO 8601 instants, though the generated schema validates only a
  * string, so this package carries whatever the manager produced without reformatting
  * it. `pollIntervalMs` is the manager's hint about how often the client can ask
- * again; a manager that pushes notifications instead simply omits it.
+ * again; a manager that pushes notifications instead omits it.
  */
 export declare type MCPTask = {
     /** Holds the durable handle a later `tasks/get` / `tasks/update` / `tasks/cancel` names. */
@@ -5132,19 +5206,19 @@ export declare type MCPTask = {
 };
 
 /**
- * Issues the `tasks/*` methods over one correlated-request door — the CLIENT half of the
+ * Issues the `tasks/*` methods over one correlated-request door — the client half of the
  * stable Tasks extension, exposed as an {@link import('./types.js').MCPClientInterface}'s
  * `tasks`.
  *
  * @remarks
  * - **The mirror of the server-side port, minus `start`.** An
  *   {@link import('./types.js').MCPTaskManagerInterface} is the consumer's durable store the
- *   SERVER creates tasks in; this is the client's read/answer/stop access to the tasks a peer
+ *   server creates tasks in; this is the client's read/answer/stop access to the tasks a peer
  *   already created. Creation is missing on purpose: the extension gives a client no flag and
  *   no parameter to ask for a task, so `start` has no wire method to be.
  * - **No plural accessor, no loop, no cache.** MCP defines no `tasks/list`, so nothing here
  *   enumerates. A task snapshot's `pollIntervalMs` is carried untouched and a one-shot read
- *   sits beside it; the SCHEDULE is the consumer's, because this package has no durable place
+ *   sits beside it; the schedule is the consumer's, because this package has no durable place
  *   to keep a task, no idea when the application still cares, and no lifetime to hang a timer
  *   on that outlives the request it was born from. An instance left alone writes nothing.
  * - **One channel.** Every request goes through the injected
@@ -5176,16 +5250,16 @@ export declare class MCPTaskClient implements MCPTaskClientInterface {
 }
 
 /**
- * Reads, answers, and stops a durable task the peer created — the CLIENT half of the stable
+ * Reads, answers, and stops a durable task the peer created — the client half of the stable
  * Tasks extension.
  *
  * @remarks
  * The mirror of {@link MCPTaskManagerInterface} minus `start`, because creating a task is
  * never the client's decision: the extension gives a client no flag and no parameter to ask
- * for one, and a task exists only because the SERVER deferred a `tools/call` it received. The
+ * for one, and a task exists only because the server deferred a `tools/call` it received. The
  * methods that remain are the `tasks/*` methods on the wire.
  *
- * There is deliberately NO plural accessor, for the same reason the server-side port has none:
+ * There is deliberately no plural accessor, for the same reason the server-side port has none:
  * the extension defines no `tasks/list`, and an accessor that could enumerate tasks would
  * invite one. The absence is how this contract states that.
  *
@@ -5210,13 +5284,13 @@ export declare interface MCPTaskClientInterface {
      * Reads one durable task's current snapshot.
      *
      * @remarks
-     * REJECTS rather than answering `undefined` for a task it cannot read. The peer's refusal
+     * rejects rather than answering `undefined` for a task it cannot read. The peer's refusal
      * is byte-identical across a task that never existed, one whose TTL purged it, and one this
      * caller is not entitled to see — that indistinguishability is the extension's whole
      * anti-enumeration property — so manufacturing a lookup-miss here would mean matching on
      * the peer's message text and publishing a difference the peer refused to publish.
      *
-     * The peer's payload is carried VERBATIM once it proves well-formed. A modern result's own
+     * The peer's payload is carried verbatim once it proves well-formed. A modern result's own
      * `resultType: 'complete'` and `_meta` stamps therefore ride along on the snapshot, because
      * rebuilding the object to drop them would also drop the unrecognized members this
      * package deliberately preserves.
@@ -5237,7 +5311,7 @@ export declare interface MCPTaskClientInterface {
      *
      * @remarks
      * The responses are keyed by the request keys the task itself published, and they travel
-     * VERBATIM: a key the task does not recognize, or has already answered, is the manager's to
+     * verbatim: a key the task does not recognize, or has already answered, is the manager's to
      * ignore rather than this client's to refuse. A partial set of answers is legal.
      *
      * @param id - The `taskId` the responses belong to
@@ -5255,14 +5329,14 @@ export declare interface MCPTaskClientInterface {
      * Asks one durable task to stop.
      *
      * @remarks
-     * ADVISORY, exactly like the server-side port it mirrors: the acknowledgement reports that
+     * advisory, exactly like the server-side port it mirrors: the acknowledgement reports that
      * the request was accepted, never that the task stopped, and a task whose work cannot be
      * interrupted may legally reach `completed` afterwards. Read the task again to learn what
      * happened.
      *
      * This is a different mechanism from `call`'s `options.signal`, which withdraws one caller
      * from one in-flight request and never reaches a task. A call that already answered
-     * `resultType: 'task'` is a request that is OVER; only this method reaches the work it left
+     * `resultType: 'task'` is a request that is over; only this method reaches the work it left
      * behind.
      *
      * @param id - The `taskId` to stop
@@ -5298,14 +5372,14 @@ export declare interface MCPTaskClientOptions {
  * {@link MCPTaskManagerInterface.start}.
  *
  * @remarks
- * It carries NO cancellation signal, and that absence is deliberate rather than an
- * omission. The signal on the accompanying {@link MCPMethodOptions} is the REQUEST's
+ * It carries no cancellation signal, and that absence is deliberate rather than an
+ * omission. The signal on the accompanying {@link MCPMethodOptions} is the request's
  * lifetime, and a deferred request ends the moment its `resultType: 'task'` answer is
  * written — a transport aborts it as soon as the response body is flushed. A manager
  * that plumbs `options.signal` into the task's work therefore loses every task it
  * creates, milliseconds after creating it, and the loss looks exactly like a client
  * that disconnected. Use `options.signal` for work that must finish before the
- * ANSWER is written, and give the task's own work a lifetime the manager owns.
+ * answer is written, and give the task's own work a lifetime the manager owns.
  *
  * `call` is the canonical tool call the deferral is standing in for, so a manager
  * needs nothing from `request.params` to run the work; `request` is supplied whole
@@ -5327,7 +5401,7 @@ export declare interface MCPTaskContext {
  * `completed` carries the deferred call's result, `failed` carries the JSON-RPC error
  * that ended it, and `working` / `cancelled` carry nothing extra. Narrow on `status`.
  *
- * `result` is an OPEN RECORD rather than an {@link MCPResult} or an
+ * `result` is an open record rather than an {@link MCPResult} or an
  * {@link MCPCallResult}, because the schema declares it one: a completed task's payload
  * is whatever the deferred method answered, and the extension constrains nothing inside
  * it — not even a `resultType`. Only `tools/call` can be deferred today, and the
@@ -5353,9 +5427,9 @@ export declare type MCPTaskDetail = (MCPTask & {
  * Represents the wire answer to `tasks/get` — one snapshot under the completed-result stamp.
  *
  * @remarks
- * DISTINCT from {@link MCPTaskDetail}, and the distinction is the whole point. A detail is
+ * distinct from {@link MCPTaskDetail}, and the distinction is the whole point. A detail is
  * what the consumer's {@link MCPTaskManagerInterface} answers, unstamped, because a durable
- * store knows nothing about the request that read it. This is what a `tasks/get` REPLY
+ * store knows nothing about the request that read it. This is what a `tasks/get` reply
  * carries: the schema types that reply as the detail intersected with the standard result,
  * so `resultType: 'complete'` is required rather than incidental and a peer that omits it
  * has answered something other than the method's declared result.
@@ -5374,15 +5448,15 @@ export declare type MCPTaskDetailResult = MCPTaskDetail & {
  * Decides whether the `tools/call` in hand becomes a durable task.
  *
  * @remarks
- * Deferral is entirely the SERVER's decision. The extension gives a client no flag and
+ * Deferral is entirely the server's decision. The extension gives a client no flag and
  * no parameter to ask for a task; the client only declares that it can cope with one.
  * So this handler is where the policy lives — long-running tool, queue depth, caller
  * tier, time of day — and it is consulted only for a client that declared the
  * capability on the request in hand.
  *
- * The returned string is the STABLE OPERATION KEY the manager deduplicates on: the same
+ * The returned string is the stable operation key the manager deduplicates on: the same
  * logical call must produce the same key, and two different calls must not. Mint it from
- * the CALLER and the canonical call — never from `call.id`, which is the client's own
+ * the caller and the canonical call — never from `call.id`, which is the client's own
  * JSON-RPC request id: a retry of one logical call changes it, so dedup never fires, and
  * two principals whose clients both started counting at 1 collide on it.
  *
@@ -5402,18 +5476,18 @@ export declare type MCPTaskHandler = (context: MCPTaskContext, options: MCPMetho
  * package creates tasks through and reads them back from.
  *
  * @remarks
- * There is deliberately NO plural accessor. The extension defines no `tasks/list`, and
+ * There is deliberately no plural accessor. The extension defines no `tasks/list`, and
  * a port that could enumerate tasks would invite one; the absence is how this contract
  * states the non-goal.
  *
  * {@link task} answers `undefined` for a task that never existed, one whose TTL purged
- * it, AND one this caller is not entitled to see. They are indistinguishable ON
- * PURPOSE: they all become the same `-32602`, so a `taskId` cannot be probed for
+ * it, and one this caller is not entitled to see. They are indistinguishable on
+ * purpose: they all become the same `-32602`, so a `taskId` cannot be probed for
  * existence. A manager that distinguishes them — by throwing for the unauthorized case,
  * say — turns its own store into an enumeration oracle no matter what this package does.
  *
  * Every method receives the resolved per-request options and is expected to
- * AUTHORIZE the call itself: the extension requires authorization on each task request,
+ * authorize the call itself: the extension requires authorization on each task request,
  * and this package has no principal of its own to check one against.
  */
 export declare interface MCPTaskManagerInterface {
@@ -5421,8 +5495,7 @@ export declare interface MCPTaskManagerInterface {
      * Creates — or returns the existing — durable task for one stable operation key.
      *
      * @remarks
-     * The obligations this package cannot enforce, and one consequence that is easy
-     * to miss:
+     * The obligations this package cannot enforce, and one consequence a reader can miss:
      *
      * - **Durability before return.** The returned task MUST already be retrievable by
      *   {@link task} when this resolves. This package awaits `start` before it builds the
@@ -5431,10 +5504,10 @@ export declare interface MCPTaskManagerInterface {
      * - **A `taskId` must resist enumeration.** It is a bearer handle over a durable
      *   operation. Mint it from a cryptographic source; do not derive it from `key`, from
      *   a counter, or from anything a caller can predict.
-     * - **Deduplicate by key, and SCOPE THE KEY TO ITS PRINCIPAL.** Returning the existing
+     * - **Deduplicate by key, and scope the key to its principal.** Returning the existing
      *   task for a repeated key is what makes a retried call idempotent. But a key that is
      *   not scoped to the caller means two principals submitting the same key receive the
-     *   SAME task — one principal reading another's work through a handle it merely
+     *   same task — one principal reading another's work through a handle it merely
      *   guessed. This package forwards `key` unchanged, exactly as the handler produced
      *   it, and has no principal to scope it by; the scoping belongs here, or in the
      *   handler that mints the key.
@@ -5449,7 +5522,7 @@ export declare interface MCPTaskManagerInterface {
      * Reads one task's current snapshot.
      *
      * @remarks
-     * EVERY `tasks/*` method runs through here first, not only `tasks/get`. {@link update}
+     * every `tasks/*` method runs through here first, not only `tasks/get`. {@link update}
      * and {@link abort} answer `void`, so neither has a way to say "no such task" and neither
      * can be the place authorization is decided; this is. Expect one read of the named task
      * before every update and every cancellation, and expect an `undefined` answer to end that
@@ -5465,11 +5538,11 @@ export declare interface MCPTaskManagerInterface {
      *
      * @remarks
      * Responses are keyed by the request keys the task published. A key the task does not
-     * recognize, or has already been answered, is IGNORED rather than refused, and a
+     * recognize, or has already been answered, is ignored rather than refused, and a
      * partial set of answers is acceptable. This package forwards the client's record
-     * VERBATIM — it holds none of the task's keys, so the ignoring is this method's to do.
+     * verbatim — it holds none of the task's keys, so the ignoring is this method's to do.
      *
-     * This is the SECOND multi-round-trip mechanism in the package, and it is the weaker one.
+     * This is the second multi-round-trip mechanism in the package, and it is the weaker one.
      * The built-in input path binds each round with a sealed `requestState`, an argument digest,
      * an absolute expiry, and the resolved principal; this path has none of them, because MCP
      * neither issued the question nor owns the channel it is answered on. Anything equivalent
@@ -5485,7 +5558,7 @@ export declare interface MCPTaskManagerInterface {
      * Asks one task to stop.
      *
      * @remarks
-     * Cancellation is COOPERATIVE: a task that has already finished, or one whose work
+     * Cancellation is cooperative: a task that has already finished, or one whose work
      * cannot be interrupted, may legally reach `completed` after this resolves. The
      * acknowledgement says the request was accepted, never that the task stopped.
      *
@@ -5514,7 +5587,7 @@ export declare type MCPTaskNotification = JSONRPCNotification & {
  * stamped with the subscription that delivered it.
  *
  * @remarks
- * FLAT, and that is the schema's shape rather than a choice: the extension types these
+ * flat, and that is the schema's shape rather than a choice: the extension types these
  * parameters as the notification envelope intersected with the detail, so every task field
  * sits directly under `params` and no `task` wrapper member exists. Narrow on `status`
  * exactly as with {@link MCPTaskDetail}.
@@ -5549,9 +5622,9 @@ export declare interface MCPTaskOptions {
  * Represents the modern `tools/call` result announcing that the call became a durable task.
  *
  * @remarks
- * The only result in this package whose `resultType` is `'task'`. It is FLAT — the
+ * The only result in this package whose `resultType` is `'task'`. It is flat — the
  * task's fields sit beside the discriminator rather than under a `task` member — and
- * it carries no terminal payload, because a task that has just been created has no
+ * it carries no terminal payload, because a task at creation has no
  * outcome yet. The outcome arrives through {@link MCPTaskDetail}.
  */
 export declare type MCPTaskResult = MCPTask & {
@@ -5564,14 +5637,14 @@ export declare type MCPTaskResult = MCPTask & {
  * Names the lifecycle state of one durable task.
  *
  * @remarks
- * `completed`, `failed`, and `cancelled` are TERMINAL: a task that reaches one never
+ * `completed`, `failed`, and `cancelled` are terminal: a task that reaches one never
  * moves again. `failed` reports that the deferred call could not be executed at all —
- * a JSON-RPC-level failure. A tool that RAN and returned an error is `completed`
+ * a JSON-RPC-level failure. A tool that ran and returned an error is `completed`
  * carrying an `isError: true` result, exactly as an inline `tools/call` would answer,
  * because the deferral must not change what the tool's own failure means.
  *
  * `input_required` collides by spelling with {@link MCPInputResult}'s `resultType`
- * and is a DIFFERENT mechanism: that one suspends a live request and resumes through
+ * and is a different mechanism: that one suspends a live request and resumes through
  * a protected `requestState` on the next `tools/call`, while this one suspends a
  * durable task and resumes through `tasks/update`. Neither spelling is this package's
  * to change — both are on the wire.
@@ -5602,15 +5675,15 @@ export declare type MCPTextStream = AsyncGenerator<string, string, unknown>;
  * 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
@@ -5619,11 +5692,11 @@ export declare type MCPTextStream = AsyncGenerator<string, string, unknown>;
  * 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.
@@ -5658,7 +5731,7 @@ export declare class MCPTextStreamController implements MCPTextStreamControllerI
      * @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
@@ -5684,7 +5757,7 @@ export declare class MCPTextStreamController implements MCPTextStreamControllerI
      *
      * @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
      */
@@ -5702,27 +5775,27 @@ export declare class MCPTextStreamController implements MCPTextStreamControllerI
  * already serialized.
  *
  * @remarks
- * A TRANSLATION boundary and nothing more: it serializes each message, and every lifecycle
+ * A translation boundary and nothing more: it serializes each message, and every lifecycle
  * decision — cancellation, abort, closure — ends the controlled typed stream beneath it, so
  * the string face never becomes a second cancellation engine with its own queue to fall
  * behind. `stop()` reaches the typed producer, which is why a transport holding only the
  * serialized arm can still end the exchange it is writing.
  *
  * {@link MCPTextStreamControllerInterface.return} is the one member that narrows rather than
- * passes through, and the narrowing is inherent: it is handed a STRING, so it has no typed
+ * passes through, and the narrowing is inherent: it is handed a string, so it has no typed
  * terminal to close the exchange on and never parses one back out of its argument. The typed
- * exchange therefore ends with NO terminal while this face answers its own consumer with the
+ * exchange therefore ends with no terminal while this face answers its own consumer with the
  * supplied text — so a cooperating producer runs its cancellation path here where the typed
  * {@link MCPStreamControllerInterface.return} would have run its normal return.
  *
  * **The ownership obligation is identical and it is not discharged twice.** Whoever is handed
- * this face ends it on EVERY exit, and every closure member here reaches the TYPED exchange
+ * this face ends it on every exit, and every closure member here reaches the typed exchange
  * beneath — so releasing the serialized arm releases the producer, the request lifetime, and
  * the live server slot behind it. A serialized pump therefore owns exactly what a typed pump
  * owns, and neither has an owner of last resort to fall back on.
  *
  * A conforming {@link MCPTextStreamControllerInterface.[Symbol.asyncDispose] | asyncDispose}
- * releases the typed producer, request lifetime, and live slot BEFORE it may reject. Throwing
+ * releases the typed producer, request lifetime, and live slot before it may reject. Throwing
  * before delegating would let a disposal fault mask the pump's original failure while leaking
  * the exchange.
  */
@@ -5734,19 +5807,19 @@ export declare interface MCPTextStreamControllerInterface extends MCPTextStream
      */
     next(): Promise<IteratorResult<string, string>>;
     /**
-     * Ends the exchange because the consumer already has its answer.
+     * Ends the serialized exchange on the text supplied by its consumer.
      *
      * @remarks
-     * The typed exchange ends with NO terminal: a string is not a {@link JSONRPCResponse}, and
+     * The typed exchange ends with no terminal: a string is not a {@link JSONRPCResponse}, and
      * this face never parses one back out of its argument. The supplied text is the answer to
-     * THIS consumer alone.
+     * this consumer alone.
      *
      * @param value - The serialized terminal the consumer is ending on
      * @returns That terminal as the iteration's `return`
      */
     return(value: string | PromiseLike<string>): Promise<IteratorResult<string, string>>;
     /**
-     * Ends the exchange with a failure the consumer is raising.
+     * Ends the serialized exchange with the failure supplied by its consumer.
      *
      * @param error - The failure to end the exchange with
      * @returns Never — the returned promise always rejects with the supplied failure
@@ -5814,13 +5887,13 @@ export declare interface MCPToolUseContent {
  * Messages are already-serialized JSON-RPC strings; the transport owns framing
  * (a WS text frame, an SSE `data:` event, a newline-terminated stdio line, a
  * `postMessage` payload) and never parses the string itself. `listen` and
- * `closed` each register THE SINGLE handler for their event — a second call
- * REPLACES the first (matching the emitter-free, minimal-surface carrier idiom
+ * `closed` each register the single handler for their event — a second call
+ * replaces the first (matching the emitter-free, minimal-surface carrier idiom
  * `bindServer` / `bindClient` themselves rely on), not an additive subscription
  * list.
  *
  * `closed` reads as an adjective where the naming law asks for a verb, and it is
- * KEPT: it is a registrar for the port's terminal event, paired with `listen` for
+ * kept: it is a registrar for the port's terminal event, paired with `listen` for
  * the other one, and no verb states that without lying. `close()` is already taken
  * by the imperative on the line below it, `end`/`stop` would read as a second way to
  * close, and `onClose` is the `on`-prefixed shape the rules reject outright. The
@@ -5831,20 +5904,20 @@ export declare interface MCPToolUseContent {
 export declare interface MCPTransportInterface {
     /** Delivers one outbound JSON-RPC message (already serialized). */
     readonly send: (message: string) => void | Promise<void>;
-    /** Registers the single inbound-message handler — a second call REPLACES the first. */
+    /** Registers the single inbound-message handler — a second call replaces the first. */
     readonly listen: (handler: (message: string) => void) => void;
-    /** Registers the single closed handler — a second call REPLACES the first. */
+    /** Registers the single closed handler — a second call replaces the first. */
     readonly closed: (handler: () => void) => void;
     /** Closes the underlying channel. */
     readonly close: () => void | Promise<void>;
 }
 
 /**
- * Represents a `tools/call` result BEFORE the modern stamp — the executed tool's output as
+ * Represents a `tools/call` result before the modern stamp — the executed tool's output as
  * `content` blocks, with `isError` flagging a tool failure.
  *
  * @remarks
- * The name states the whole distinction: this is the tool-call result WITHOUT
+ * The name states the whole distinction: this is the tool-call result without
  * `resultType`, which is the only shape the legacy revision has for one.
  * {@link MCPCallResult} is this payload plus the modern `'complete'` stamp, so
  * stamping is the one difference between the modern and legacy answers to `tools/call`.
@@ -5853,8 +5926,8 @@ export declare interface MCPTransportInterface {
  *
  * A success carries the tool's value unchanged as `structuredContent` alongside
  * its serialized form in one `text` content block. A value-less success omits
- * `structuredContent`. A tool FAILURE (the `success: false` branch the registry
- * isolated) carries its `error` text in `content` AND sets `isError: true`, so the
+ * `structuredContent`. A tool failure (the `success: false` branch the registry
+ * isolated) carries its `error` text in `content` and sets `isError: true`, so the
  * model sees the failure as a tool result it can react to rather than a protocol
  * error.
  */
@@ -5901,19 +5974,19 @@ export declare function modernResultToLegacy(result: MCPResult | MCPLegacyResult
  *
  * @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:
  *
@@ -5921,12 +5994,12 @@ export declare function modernResultToLegacy(result: MCPResult | MCPLegacyResult
  *   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.
@@ -5950,11 +6023,11 @@ export declare function parseJSONRPCMessage(value: unknown, limits?: MCPJSONLimi
  * @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
@@ -5974,7 +6047,7 @@ export declare function parseMCPInputState(value: unknown): MCPInputState | unde
  * 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
@@ -5993,7 +6066,7 @@ export declare function parseRequestContext(value: unknown, limits?: MCPJSONLimi
  * {@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
@@ -6011,15 +6084,15 @@ export declare function readCancelledId(message: JSONRPCMessage): JSONRPCId | un
 
 /**
  * Decodes a `fetch` Response's Server-Sent-Events body into the JSON-RPC messages it
- * carried — the CLIENT-side inverse of a server's Streamable-HTTP SSE response.
+ * carried — the client-side inverse of a server's Streamable-HTTP SSE response.
  *
  * @remarks
  * Reads the whole `response.body` stream chunk-by-chunk through a `TextDecoder({ stream: true
  * })` (handling a multi-byte character split across reads) and `@orkestrel/sse`'s
  * {@link SSEParserInterface} (handling a partial line or in-progress event split across
  * reads), then narrows each dispatched event's `data` to a {@link JSONRPCMessage} through
- * {@link decodeEvent} (so a non-message or non-JSON `data:` event is DROPPED, never thrown —
- * total). It reuses the SAME `SSEParser` a server's `createStream` seam serializes against, so
+ * {@link decodeEvent} (so a non-message or non-JSON `data:` event is dropped, never thrown —
+ * total). It reuses the same `SSEParser` a server's `createStream` seam serializes against, so
  * the wire round-trips. A `null` body (no stream) yields no messages;
  * {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} reads a
  * request/response SSE reply (the server sends one `data:` event then ends), so this drains to
@@ -6039,11 +6112,11 @@ export declare function readEventStream(response: Response): Promise<readonly JS
  * 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
@@ -6060,14 +6133,14 @@ export declare function renderHeaderValue(value: unknown, primitive: MCPHeaderPr
 
 /**
  * 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
@@ -6077,7 +6150,7 @@ export declare function renderHeaderValue(value: unknown, primitive: MCPHeaderPr
  * 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.
  *
@@ -6161,7 +6234,10 @@ export declare function snapshotToolResult(value: unknown, limits: MCPJSONLimitO
  */
 export declare function stampSubscriptionNotification(notification: JSONRPCNotification, id: JSONRPCId): JSONRPCNotification;
 
-/** Lists the protocol revisions accepted by the optional legacy decorator. */
+/**
+ * Lists the protocol revisions accepted by the optional legacy decorator, `2025-11-25` and
+ * `2025-06-18`.
+ */
 export declare const SUPPORTED_LEGACY_PROTOCOL_VERSIONS: readonly MCPLegacyVersion[];
 
 /**
@@ -6171,7 +6247,7 @@ export declare const SUPPORTED_LEGACY_PROTOCOL_VERSIONS: readonly MCPLegacyVersi
 export declare const SUPPORTED_MCP_VERSIONS: readonly MCPVersion[];
 
 /**
- * Lists the modern MCP protocol revisions a bare server accepts and advertises.
+ * Lists the modern MCP protocol revisions a bare server accepts and advertises, `2026-07-28`.
  *
  * @remarks
  * Frozen in discovery-advertisement order. Legacy revisions are absent because
@@ -6204,14 +6280,14 @@ export declare function supportsFormElicitation(value: unknown): boolean;
  *
  * @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.
  *