@orkestrel/mcp 0.0.28 → 0.0.29

package/README.md

@@ -1,15 +1,12 @@
 # @orkestrel/mcp
 
-A typed [Model Context Protocol](https://modelcontextprotocol.io) client/server
-for the `@orkestrel` line, bridging the `@orkestrel/tool` registry to MCP with
-pluggable HTTP, WebSocket, and stdio transports. `createMCPServer` exposes a
-live `ToolManagerInterface`; `createMCPClient` drives a remote MCP server and
-surfaces its tools as local `ToolInterface`s. No agent runtime is required.
-The dispatch core is transport- and provider-agnostic
-(`src/core` — JSON-RPC 2.0, no HTTP, no `as`); every transport (Streamable
-HTTP over `@orkestrel/router` / `@orkestrel/server`, WebSocket over
-`@orkestrel/websocket`, and stdio over `@orkestrel/process`) lives one layer
-out (`src/server`), each mechanism, not policy. Part of the `@orkestrel` line.
+> The Model Context Protocol layer: a typed JSON-RPC 2.0 client/server pair with pluggable
+> HTTP, WebSocket, stdio, and browser transports.
+
+Bridge the `@orkestrel/tool` registry to MCP: `createMCPServer` exposes a live
+`ToolManagerInterface` to any MCP client, and `createMCPClient` drives a remote MCP server
+and surfaces its tools as local `ToolInterface`s. No agent runtime is required. Part of the
+`@orkestrel` line.
 
 ## Install
 
@@ -30,8 +27,6 @@ npm install @orkestrel/mcp
 
 ## Usage
 
-Expose a tool registry over MCP, mounted on the HTTP spine:
-
 ```ts
 import { createMCPLegacy, createMCPServer } from '@orkestrel/mcp'
 import { createMCPRoutes } from '@orkestrel/mcp/server'
@@ -46,6 +41,8 @@ const routes = createMCPRoutes(createMCPLegacy(mcp)) // answers `initialize` too
 router.add(routes)
 ```
 
+This example exposes a tool registry over MCP, mounted on the HTTP spine.
+
 Drive a remote MCP server as a client, over the same transport-agnostic core:
 
 ```ts
@@ -60,7 +57,7 @@ const tools = await client.tools()
 const outcome = await client.call('add', { x: 2, y: 5 })
 ```
 
-The SAME `MCPClient` drives a `createWebSocketClientTransport` or
+The same `MCPClient` drives a `createWebSocketClientTransport` or
 `createStdioClientTransport` instead — only the injected transport changes.
 
 ## Guide
@@ -96,7 +93,7 @@ The publication facts, each with its number. Full detail, plus every
 protocol-level gap and non-goal, is in
 [the MCP guide](https://github.com/orkestrel/mcp/blob/main/guides/mcp.md#declared-packaging-limits).
 
-- **No IDE evidence.** See above. The conformance number is about the wire
+- **No IDE evidence.** See the [wire conformance evidence](https://github.com/orkestrel/mcp#proven). The conformance number is about the wire
   and does not transfer to a host application.
 - **No top-level `types` field.** Every `exports` subpath carries a `types`
   condition, so `node16`, `nodenext`, and `bundler` resolution find

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

@@ -1,18 +1,16 @@
-import { EmitterInterface } from '@orkestrel/emitter';
-import { HTTPClientTransportOptions } from '@orkestrel/mcp';
-import { JSONRPCMessage } from '@orkestrel/mcp';
-import { MCPMessageTransportEventMap } from '@orkestrel/mcp';
-import { MCPMessageTransportInterface } from '@orkestrel/mcp';
-import { MCPMessageTransportInterface as MCPMessageTransportInterface_2 } from '@orkestrel/mcp';
-import { MCPServerInterface } from '@orkestrel/mcp';
-import { MCPTransportInterface } from '@orkestrel/mcp';
-import { MCPTransportInterface as MCPTransportInterface_2 } from '@orkestrel/mcp';
-import { ToolManagerInterface } from '@orkestrel/tool';
+import type { EmitterInterface } from '@orkestrel/emitter';
+import type { HTTPClientTransportOptions } from '@orkestrel/mcp';
+import type { JSONRPCMessage } from '@orkestrel/mcp';
+import type { MCPMessageTransportEventMap } from '@orkestrel/mcp';
+import type { MCPMessageTransportInterface } from '@orkestrel/mcp';
+import type { MCPServerInterface } from '@orkestrel/mcp';
+import type { MCPTransportInterface } from '@orkestrel/mcp';
+import type { ToolManagerInterface } from '@orkestrel/tool';
 
 /**
- * Creates the HTTP CLIENT transport for an
+ * Creates the HTTP client transport for an
  * {@link import('@orkestrel/mcp').MCPClientInterface} — a {@link MCPMessageTransportInterface}
- * that drives a REMOTE Streamable-HTTP MCP server over the native `fetch`.
+ * that drives a remote Streamable-HTTP MCP server over the native `fetch`.
  *
  * @remarks
  * It returns the core {@link import('@orkestrel/mcp').HTTPClientTransport}, the same class the
@@ -24,18 +22,18 @@ import { ToolManagerInterface } from '@orkestrel/tool';
  * Hand it to `createMCPClient({ transport })`: each JSON-RPC message the client
  * sends is `POST`ed to `options.url` with `content-type: application/json` and an
  * `Accept` of both `application/json` and `text/event-stream` (the server answers
- * with EITHER — a plain JSON envelope or a Streamable-HTTP SSE `data:` event,
+ * with either — a plain JSON envelope or a Streamable-HTTP SSE `data:` event,
  * decoded with `@orkestrel/sse`), and the reply is surfaced on the transport's
  * `message` event for the client's id correlation. Add `options.headers` (for example, an
  * `Authorization` bearer) to reach a guarded server. `start` / `close` hold no
- * connection; against a STATEFUL server it captures the `mcp-session-id` from
+ * connection; against a stateful server it captures the `mcp-session-id` from
  * `initialize` and echoes it on later requests. It also captures the initialize
  * result's `protocolVersion` and sends `mcp-protocol-version` alone on subsequent
  * legacy requests. Modern requests instead derive `mcp-protocol-version` and
  * `mcp-method` from the message, plus `mcp-name` only for `tools/call`, so the
  * same `MCPClient` passes either era's protocol gates without caller wiring.
  *
- * @param options - `url` (the remote endpoint; REQUIRED), optional `headers` merged
+ * @param options - `url` (the remote endpoint; required), optional `headers` merged
  *   onto every request, optional `fetch` (default `globalThis.fetch`), and optional
  *   `timeout` (ms, applied with `AbortSignal.timeout`); see
  *   {@link HTTPClientTransportOptions}
@@ -53,12 +51,12 @@ import { ToolManagerInterface } from '@orkestrel/tool';
  * const tools = await client.tools()
  * ```
  */
-export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): MCPMessageTransportInterface_2;
+export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): MCPMessageTransportInterface;
 
 /**
  * Creates the browser-face `MessagePort` transport — a
  * {@link import('@orkestrel/mcp').MCPTransportInterface} over a native `MessagePort`, the
- * SYMMETRIC carrier that works as either a server or a client transport depending on
+ * symmetric carrier that works as either a server or a client transport depending on
  * which binder ({@link import('@orkestrel/mcp').bindServer} or
  * {@link import('@orkestrel/mcp').bindClient}) it is handed to.
  *
@@ -68,7 +66,7 @@ export declare function createHTTPClientTransport(options: HTTPClientTransportOp
  * dropped, never thrown); `messageerror` is ignored (one bad frame does not close the
  * channel); `close()` closes the port and fires `closed` exactly once.
  *
- * @param options - `port` (the `MessagePort` half to drive; REQUIRED); see
+ * @param options - `port` (the `MessagePort` half to drive; required); see
  *   {@link MessagePortTransportOptions}
  * @returns A working {@link import('@orkestrel/mcp').MCPTransportInterface} over the port
  *
@@ -86,28 +84,28 @@ export declare function createMessagePortTransport(options: MessagePortTransport
 
 /**
  * Builds {@link createScopeServer}'s `message`-event listener — the unified dispatcher that
- * routes EVERY inbound event on a hostable scope, portless or port-bearing, to the right
+ * routes every inbound event on a hostable scope, portless or port-bearing, to the right
  * binding.
  *
  * @remarks
- * Port-bearing events (`event.ports.length > 0`) are gated by `options.accept` FIRST
+ * Port-bearing events (`event.ports.length > 0`) are gated by `options.accept` first
  * — when the gate returns `false` the event is dropped entirely (no binding, no reply).
  * Accepted events spawn a fresh `MessagePortTransport` over `event.ports[0]`,
  * `bindServer` `server` onto it, and record a teardown (`unbind` then `transport.close()`)
- * into `teardowns` KEYED BY THAT PORT. A port already present is IGNORED — repeated delivery
+ * into `teardowns` keyed by that port. A port already present is ignored — repeated delivery
  * of the same `MessagePort` would create duplicate bindings over one port (→ duplicated
  * replies), so a repeat is silently dropped.
  *
- * The key is what makes `teardowns` the ONLY place an accepted port is remembered. A separate
+ * The key is what makes `teardowns` the only place an accepted port is remembered. A separate
  * seen-port set would be a second collection over the same lifetime, and the scope server's
  * `stop` would have to remember to empty both — so a long-lived scope such as a Service Worker
  * would retain every port it ever accepted, closed and unbound ones included. Membership
  * answers "already bound?" and `clear()` drops the binding and the dedup together.
  *
- * This branch fires on EITHER a Service-Worker-shaped scope (its normal per-client
+ * This branch fires on either a Service-Worker-shaped scope (its normal per-client
  * channel) or a dedicated-worker-shaped one that happens to receive a port-bearing event
  * (the unified design's deliberate cross-case, needing no upfront shape flag). An event
- * with NO ports and a STRING `data` is pushed onto `scopeTransport.deliver` (the
+ * with no ports and a string `data` is pushed onto `scopeTransport.deliver` (the
  * implicit, already-bound scope channel); any other event (no ports, non-string data)
  * is silently dropped — total, never throws.
  *
@@ -170,7 +168,7 @@ export declare function createScopeServer(options: ScopeServerOptions, scope?: S
  *
  * @remarks
  * `send` writes each outbound string through `scope.postMessage`. `listen`/`closed`
- * register the SINGLE handler `deliver` / the underlying close path route through —
+ * register the single handler `deliver` / the underlying close path route through —
  * the scope server's own `scope` `message`-event listener calls `deliver(event.data)`
  * for every portless, string-payload event (there is no native registration point on
  * the scope itself for the scope server to hand a `listen` handler to, so `deliver` is
@@ -190,20 +188,20 @@ export declare function createScopeServer(options: ScopeServerOptions, scope?: S
 export declare function createScopeTransport(scope: ScopeInterface): ScopeTransportInterface;
 
 /**
- * Creates the browser-face WebSocket CLIENT transport for an
+ * Creates the browser-face WebSocket client transport for an
  * {@link import('@orkestrel/mcp').MCPClientInterface} — a {@link MCPMessageTransportInterface}
- * that drives a REMOTE MCP server over the native `WebSocket` global, the browser
- * sibling of the Node face's `createWebSocketClientTransport` (`@orkestrel/mcp/server`).
+ * that drives a remote MCP server over the native `WebSocket` global. This factory is the
+ * browser sibling of the Node face's `createWebSocketClientTransport` (`@orkestrel/mcp/server`).
  *
  * @remarks
  * Hand it to `createMCPClient({ transport })`: `start()` (run by `client.connect()`)
  * opens `new WebSocket(options.url, options.protocols)` and awaits the native
  * `'open'` event — the RFC 6455 handshake itself is the browser's concern. Each
- * JSON-RPC message the client `send`s before the socket opens is QUEUED and flushed,
+ * JSON-RPC message the client `send`s before the socket opens is queued and flushed,
  * in order, once it does; each decoded reply is surfaced on the transport's
  * `message` event for the client's id correlation.
  *
- * @param options - `url` (the remote WebSocket endpoint; REQUIRED) and optional
+ * @param options - `url` (the remote WebSocket endpoint; required) and optional
  *   `protocols` (the WebSocket subprotocol(s) to request); see
  *   {@link WebSocketClientTransportOptions}
  * @returns A working {@link MCPMessageTransportInterface} over the native `WebSocket`
@@ -220,7 +218,7 @@ export declare function createScopeTransport(scope: ScopeInterface): ScopeTransp
  * const tools = await client.tools()
  * ```
  */
-export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): MCPMessageTransportInterface_2;
+export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): MCPMessageTransportInterface;
 
 /** Supplies the default server name `createScopeServer` reports (`initialize`'s `serverInfo.name`) when `options.name` is omitted. */
 export declare const DEFAULT_MCP_SERVER_NAME = "@orkestrel/mcp";
@@ -237,33 +235,33 @@ export declare const DEFAULT_MCP_SERVER_VERSION = "1.0.0";
  * - **Symmetric.** Unlike {@link import('./WebSocketClientTransport.js').WebSocketClientTransport}
  *   / {@link import('@orkestrel/mcp').HTTPClientTransport} (CLIENT-only
  *   carriers of `@orkestrel/mcp`'s `MCPMessageTransportInterface`), a `MessagePort` is a
- *   plain duplex channel — the SAME class implements `@orkestrel/mcp`'s
- *   `MCPTransportInterface` and is handed to EITHER `bindServer` or
+ *   plain duplex channel — the same class implements `@orkestrel/mcp`'s
+ *   `MCPTransportInterface` and is handed to either `bindServer` or
  *   `bindClient`/`createDuplexClientTransport`; which role it plays comes entirely
  *   from the binder it is given to, not from anything this class decides.
  * - **`start()` at construction — bind synchronously.** `MessagePort.start()` is only
- *   REQUIRED when listening with `addEventListener` (as opposed to the `onmessage`
+ *   required when listening with `addEventListener` (as opposed to the `onmessage`
  *   setter, which implies it) — this transport uses `addEventListener`, and
  *   `MCPTransportInterface` has no separate open/connect step for the caller to hook
  *   a start into, so the constructor calls `port.start()` immediately: the port
- *   begins dispatching QUEUED messages the moment the transport exists. This is safe
+ *   begins dispatching queued messages the moment the transport exists. This is safe
  *   inside `createScopeServer`'s flow (the transport is synchronously handed to `bindServer`
  *   before control returns to the event loop), but is a **footgun for direct use**:
  *   if you construct `new MessagePortTransport({ port })` and then `await` anything
- *   before calling `listen`, messages that arrived in the gap are DROPPED. **Bind
+ *   before calling `listen`, messages that arrived in the gap are dropped. **Bind
  *   synchronously after construction** — do not interleave an `await` between
  *   `new MessagePortTransport(…)` and `bindServer` / `listen`.
  * - **String payloads only.** `send` posts the message string as-is (`postMessage`
  *   structured-clones it — a string clones to an identical string, so the wire stays
  *   plain JSON-RPC text like every other transport in this package). Inbound: a
  *   non-string `event.data` (a host or a misbehaving peer posting a structured
- *   object) is IGNORED — dropped silently, never forwarded, never thrown —
+ *   object) is ignored — dropped silently, never forwarded, never thrown —
  *   because `MCPTransportInterface` carries no `error` channel for this port to
  *   surface a non-string frame on (unlike `MCPMessageTransportInterface`'s `emitter`);
  *   silently ignoring is the total, contract-shaped choice.
- * - **`messageerror` is IGNORED, not routed to `closed`.** A `messageerror` event
+ * - **`messageerror` is ignored, not routed to `closed`.** A `messageerror` event
  *   (the structured-clone deserialization of an inbound message threw) reports one
- *   BAD FRAME, not a dead channel — the port itself keeps working and later, well-
+ *   bad frame, not a dead channel — the port itself keeps working and later, well-
  *   formed messages still arrive. This transport registers no listener for it: an
  *   unhandled `messageerror` on a `MessagePort` neither throws, closes the port, nor
  *   reaches this transport, so one bad frame costs exactly that frame and nothing
@@ -271,14 +269,14 @@ export declare const DEFAULT_MCP_SERVER_VERSION = "1.0.0";
  *   `bindServer`/`bindClient` wiring (and, transitively, every session it carries)
  *   over a single malformed frame.
  * - **`close()`** is idempotent: it closes the underlying `port` (`MessagePort.close()`
- *   disconnects it — further `postMessage` calls on EITHER end are silently
+ *   disconnects it — further `postMessage` calls on either end are silently
  *   undelivered, per the platform contract) and fires the registered `closed`
  *   handler exactly once, whether the caller closes it once or twice. There is no
  *   native "peer closed" signal for a `MessagePort` (unlike a WebSocket's `close`
- *   event) — `closed` fires ONLY from this transport's own `close()`.
+ *   event) — `closed` fires only from this transport's own `close()`.
  * - **Single-handler-replace (the port contract, `@orkestrel/mcp`'s `MCPTransportInterface`
  *   doc).** `listen`/`closed` each hold the one active handler; a
- *   second call REPLACES the first rather than adding a second subscriber.
+ *   second call replaces the first rather than adding a second subscriber.
  *
  * @example
  * ```ts
@@ -291,7 +289,7 @@ export declare const DEFAULT_MCP_SERVER_VERSION = "1.0.0";
  * bindClient(client, clientTransport) // port2 side is the client's carrier
  * ```
  */
-export declare class MessagePortTransport implements MCPTransportInterface_2 {
+export declare class MessagePortTransport implements MCPTransportInterface {
     #private;
     constructor(options: MessagePortTransportOptions);
     send(message: string): void;
@@ -306,7 +304,7 @@ export declare class MessagePortTransport implements MCPTransportInterface_2 {
  *
  * @remarks
  * `port` — the channel half to drive (for example, one side of a `new MessageChannel()`, or
- * the port a `message` event's `ports[0]` carried). REQUIRED. The SAME transport
+ * the port a `message` event's `ports[0]` carried). Required. The same transport
  * works as either a server or a client carrier — the role comes from whether it is
  * handed to `bindServer` or `bindClient`/`createDuplexClientTransport` (`@orkestrel/mcp`).
  */
@@ -324,7 +322,7 @@ export declare interface MessagePortTransportOptions {
  * Only the members the scope server actually touches: `postMessage` (the
  * dedicated-worker implicit reply channel), and `addEventListener` /
  * `removeEventListener` for `'message'` (every inbound event, portless or
- * port-bearing, arrives through the SAME listener — see {@link ScopeServerOptions}'s
+ * port-bearing, arrives through the same listener — see {@link ScopeServerOptions}'s
  * doc and the factory). A real `self` / `globalThis` inside a worker satisfies this
  * structurally (it exposes far more, which this narrower shape ignores).
  */
@@ -354,20 +352,20 @@ export declare interface ScopeServerInterface {
  * Options for {@link import('./factories.js').createScopeServer} — the live
  * {@link ToolManagerInterface} to expose plus the optional server identity, mirroring
  * `createMCPServer`'s `MCPServerOptions` (`@orkestrel/mcp`) but with `name`/`version`
- * OPTIONAL (defaulting to {@link import('./constants.js').DEFAULT_MCP_SERVER_NAME} /
+ * optional (defaulting to {@link import('./constants.js').DEFAULT_MCP_SERVER_NAME} /
  * {@link import('./constants.js').DEFAULT_MCP_SERVER_VERSION}).
  *
  * @remarks
  * - `accept` — optional identity gate consulted **before** a port-bearing `message`
  *   event is accepted; return `false` to drop the event (no binding, no reply).
- *   **`accept` gates ONLY port-bearing events** — portless messages bypass it and
+ *   **`accept` gates only port-bearing events** — portless messages bypass it and
  *   deliver directly to the implicit scope channel (the tool executes, blind; in a
  *   Service Worker the reply is silently dropped — see `createScopeServer`'s portless note).
  *   Prefer a handshake token in `event.data` as the primary pattern
  *   (for example, `(event) => event.data === token`) — for same-origin worker/MessagePort
  *   messages `event.origin` is frequently the empty string, making origin
  *   allow-listing unreliable; origin checks are meaningful for cross-origin
- *   `postMessage` only. When omitted, ALL port-bearing events are accepted — every
+ *   `postMessage` only. When omitted, all port-bearing events are accepted — every
  *   same-origin context that can reach the scope gets full tool-call access.
  *   See `createScopeServer`'s trust-boundary and portless-events notes.
  */
@@ -379,7 +377,7 @@ export declare interface ScopeServerOptions {
 }
 
 /**
- * Adapts a message-event-bearing SCOPE (`self` in a dedicated Web Worker, or any object
+ * Adapts a message-event-bearing scope (`self` in a dedicated Web Worker, or any object
  * shaped the same way) as a duplex {@link MCPTransportInterface} — the
  * internal carrier `createScopeServer` binds to route the implicit (portless) message
  * channel, plus the `deliver` entry point the scope's own `message` listener pushes
@@ -392,42 +390,42 @@ export declare interface ScopeTransportInterface extends MCPTransportInterface {
 }
 
 /**
- * Drives a REMOTE MCP server over the native `WebSocket` global from the browser face — a
- * CLIENT {@link MCPMessageTransportInterface}, the browser sibling of the Node face's
- * {@link import('@orkestrel/mcp/server').WebSocketClientTransport}.
+ * Drives a remote MCP server over the native `WebSocket` global from the browser face, as a
+ * client {@link MCPMessageTransportInterface}. This class is the browser sibling of the Node
+ * face's {@link import('@orkestrel/mcp/server').WebSocketClientTransport}.
  *
  * @remarks
  * - **Host-performed handshake.** `start()` opens `new WebSocket(url, protocols)` and
  *   waits for the native `'open'` event — the RFC 6455 handshake itself is entirely
  *   the host's concern, so this transport carries none of the Node client's
  *   `node:crypto` / `node:http(s)` machinery. A connection failure (the native
- *   `'error'` event while not yet `OPEN`) REJECTS `start()`.
+ *   `'error'` event while not yet `OPEN`) rejects `start()`.
  * - **Queued sends.** `send` writes each message as one text frame immediately once
  *   the socket is `OPEN`; a `send` issued before `'open'` fires (or before `start()`
- *   is even called) is QUEUED and flushed, IN ORDER, the moment the socket opens —
- *   so a caller need not await `start()` before calling `send`. A queue rides ONE
- *   connection: a close DISCARDS whatever is still in it.
- * - **A closed channel REJECTS.** The native socket confirms nothing about a write, so this
+ *   is even called) is queued and flushed, in order, the moment the socket opens —
+ *   so a caller need not await `start()` before calling `send`. A queue rides one
+ *   connection: a close discards whatever is still in it.
+ * - **A closed channel rejects.** The native socket confirms nothing about a write, so this
  *   transport answers from its own state: a `send` after `close()`, or on a socket already
- *   reporting `CLOSING` / `CLOSED`, REJECTS with `WebSocket transport is not connected` rather
+ *   reporting `CLOSING` / `CLOSED`, rejects with `WebSocket transport is not connected` rather
  *   than resolving on a frame nobody wrote. Only the closed state rejects — a pre-open `send`
  *   still queues.
  * - **Inbound (`message`).** Each decoded text frame runs through the shared
  *   `deliverMessage` fold (parse, then narrow) — a well-formed {@link JSONRPCMessage}
  *   re-emits on this transport's `message` event; a non-text (binary) frame or a
- *   non-JSON / non-message text frame surfaces on `error` and is DROPPED (never
+ *   non-JSON / non-message text frame surfaces on `error` and is dropped (never
  *   throws on adversarial wire input).
  * - **`close()`** unsubscribes from the underlying socket, closes it, and fires `close`
  *   (idempotent); the socket's native `close` event (a server-initiated close) fires the
- *   SAME `close` exactly once total — `close()` first flips the guard, so the native event
+ *   same `close` exactly once total — `close()` first flips the guard, so the native event
  *   never double-emits, and the released socket reports its own close to nobody. Closing before
  *   the socket opens resolves the pending `start()` rather than leaving it pending, matching the
- *   Node face. A `send` issued after `close()` REJECTS (it is never queued), and the
- *   pre-open queue is DISCARDED — by `close()` and by the native `close` event alike — so a
+ *   Node face. A `send` issued after `close()` rejects (it is never queued), and the
+ *   pre-open queue is discarded — by `close()` and by the native `close` event alike — so a
  *   closed transport delivers nothing until a `start()` opens a new connection, and nothing
  *   the caller handed the abandoned connection rides that one.
  * - **Observable.** Owns the `emitter` ({@link MCPMessageTransportEventMap}); every
- *   emit the emitter isolates a listener throw; `error` is a DOMAIN event (a
+ *   emit the emitter isolates a listener throw; `error` is a domain event (a
  *   transport-level fault).
  *
  * @example
@@ -455,7 +453,7 @@ export declare class WebSocketClientTransport implements MCPMessageTransportInte
  * @remarks
  * - `url` — the absolute `ws://` / `wss://` (or `http://` / `https://`, accepted by
  *   the native `WebSocket` constructor the same way) URL of the remote server's
- *   WebSocket endpoint. REQUIRED.
+ *   WebSocket endpoint. Required.
  * - `protocols` — the WebSocket subprotocol(s) to request. **Defaults to
  *   {@link import('@orkestrel/mcp').MCP_WEBSOCKET_SUBPROTOCOL} (`'mcp'`)**, which
  *   `createWebSocketServer` selects when the offer contains it. Per
@@ -471,7 +469,7 @@ export declare class WebSocketClientTransport implements MCPMessageTransportInte
  * upgrade request header at all — there is no seam for an `Authorization` bearer to reach.
  * The Node face owns its own `node:http(s)` upgrade request and therefore can, which is why
  * only that side offers `headers`. Reach a guarded server from a page with a credential the
- * platform DOES carry: a cookie the browser attaches to the upgrade, a subprotocol token, or
+ * platform does carry: a cookie the browser attaches to the upgrade, a subprotocol token, or
  * a signed value in the URL. Adding a `headers` key here would be an option that silently
  * did nothing.
  */