@orkestrel/mcp 0.0.5 → 0.0.7

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

@@ -24,8 +24,10 @@ import { ToolManagerInterface } from '@orkestrel/agent';
  * `message` event for the client's id correlation. Add `options.headers` (e.g. an
  * `Authorization` bearer) to reach a guarded server. `start` / `close` hold no
  * connection; against a STATEFUL server it captures the `mcp-session-id` from
- * `initialize` and echoes it on later requests, so the same `MCPClient` passes
- * session validation (a stateless server sends none).
+ * `initialize` and echoes it on later requests. It also captures the initialize
+ * result's `protocolVersion` and sends `mcp-protocol-version` on every subsequent
+ * request, so the same `MCPClient` passes the session and 2025-06-18 protocol
+ * gates without caller wiring.
  *
  * @param options - `url` (the remote endpoint; REQUIRED), optional `headers` merged
  *   onto every request, optional `fetch` (default `globalThis.fetch`), and optional
@@ -76,7 +78,7 @@ export declare function createHTTPClientTransport(options: HTTPClientTransportOp
 export declare function createMessagePortTransport(options: MessagePortTransportOptions): MCPTransportInterface;
 
 /**
- * Build `serveMCPScope`'s (`serve.ts`) `message`-event listener — the unified
+ * Build `serveMCPScope`'s `message`-event listener — the unified
  * dispatcher that routes EVERY inbound event on a hostable scope, portless or
  * port-bearing, to the right binding.
  *
@@ -116,7 +118,7 @@ export declare function createScopeMessageListener(server: MCPServerInterface, s
 /**
  * Adapt a hostable {@link ServeMCPScopeInterface} (`self` in a dedicated Web Worker,
  * or any structurally matching double) into a {@link ScopeTransportInterface} — the
- * implicit, portless message channel `serveMCPScope` (`serve.ts`) binds for the
+ * implicit, portless message channel `serveMCPScope` binds for the
  * dedicated-worker shape.
  *
  * @remarks
@@ -204,7 +206,7 @@ export declare const DEFAULT_MCP_SERVER_VERSION = "1.0.0";
  *
  * @remarks
  * - **Request/response over `fetch`.** `send(message)` POSTs the JSON-serialized
- *   message (or batch) to `options.url` with `content-type: application/json` and an
+ *   message to `options.url` with `content-type: application/json` and an
  *   `Accept` of BOTH `application/json` and `text/event-stream` (so the server may
  *   answer with either framing) — plus any `options.headers` (e.g. an
  *   `Authorization` bearer). It then decodes the reply and emits each decoded
@@ -216,13 +218,18 @@ export declare const DEFAULT_MCP_SERVER_VERSION = "1.0.0";
  *   face's own `readEventStream`) — the inverse of the server's `openStream` seam, so
  *   the wire round-trips. A `202` Accepted (a notification) carries no body and emits
  *   nothing.
- * - **Session echo.** `start()` / `close()` are no-ops (a request/response transport
- *   holds no long-lived connection). The `mcp-session-id` response header, when a
- *   STATEFUL server sends one (on `initialize`), is captured into `session` and then
- *   ECHOED as the `mcp-session-id` request header on every SUBSEQUENT request — so an
- *   `MCPClient` passes a stateful server's session validation. Before `initialize`
- *   returns an id, `session` is `undefined` and no header is sent (safe against a
- *   stateless server, which neither sends nor expects one).
+ * - **Session and protocol echo.** `start()` is a no-op (a
+ *   request/response transport opens no long-lived connection). The
+ *   `mcp-session-id` response header, when a STATEFUL server sends one (on
+ *   `initialize`), is captured into `session` and then ECHOED as the
+ *   `mcp-session-id` request header on every SUBSEQUENT request — so an
+ *   `MCPClient` passes a stateful server's session validation. The
+ *   initialize result's `protocolVersion` is likewise captured, but only
+ *   when it is a SUPPORTED value, and echoed as `mcp-protocol-version` on
+ *   every subsequent request, as required by the 2025-06-18 Streamable-HTTP
+ *   transport. Before initialize returns, neither captured header is sent.
+ *   `close()` clears the captured protocol so a reconnect's `initialize`
+ *   POST is headerless; the captured `session` persists across `close()`.
  * - **Total at the boundary (§14).** Every reply is narrowed (`parseJSONRPCMessage`,
  *   the SSE decoder) — a non-message reply is dropped, never asserted; a `fetch` /
  *   decode failure surfaces on the `error` event rather than escaping `send`.
@@ -242,7 +249,7 @@ export declare class HTTPClientTransport implements ClientTransportInterface {
     get emitter(): EmitterInterface<ClientTransportEventMap>;
     get session(): string | undefined;
     start(): Promise<void>;
-    send(message: JSONRPCMessage_2 | readonly JSONRPCMessage_2[]): Promise<void>;
+    send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
 
@@ -270,6 +277,13 @@ export declare interface HTTPClientTransportOptions {
     readonly timeout?: number;
 }
 
+/**
+ * The Streamable-HTTP transport header carrying the negotiated MCP protocol version
+ * on every post-initialize request. The browser HTTP client captures the initialize
+ * result's `protocolVersion` and sends this header on each subsequent request.
+ */
+export declare const MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+
 /**
  * The Streamable-HTTP transport header that carries the MCP session id. The browser
  * face's {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport}
@@ -409,35 +423,10 @@ export declare interface ScopeTransportInterface extends MCPTransportInterface {
 }
 
 /**
- * Boot an `MCPServer` inside the CURRENT hostable scope (`globalThis` — a dedicated
- * Web Worker or a Service Worker) and wire its message events to it.
- *
- * @remarks
- * A one-liner over {@link serveMCPScope}: `serveMCP(options)` is exactly
- * `serveMCPScope(globalThis, options)`. Kept as its own export so the scope-facing
- * wiring stays independently testable (AGENTS §5) — drive {@link serveMCPScope}
- * directly with a scope double for a test, and this thin wrapper for real deploys.
- *
- * **Trust boundary and lifecycle** — see {@link serveMCPScope}'s `@remarks`. The same
- * considerations apply: ENTIRE tool registry exposed to every accepted port-bearing
- * event; use `accept` to gate; per-client bindings accumulate for the scope's lifetime.
+ * Boot an `MCPServer` inside the current hostable worker scope.
  *
- * @param options - `tools` (the live registry to expose; REQUIRED), optional
- *   `name`/`version`, optional `accept` (origin/identity gate); see {@link ServeMCPOptions}
- * @returns A dispose function — see {@link serveMCPScope}
- *
- * @example
- * ```ts
- * // Inside a dedicated Web Worker's entry module:
- * import { serveMCP } from '@orkestrel/mcp/browser'
- * import { createToolManager, createTool } from '@orkestrel/agent'
- *
- * const tools = createToolManager()
- * tools.add(createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
- * const dispose = serveMCP({ tools, name: 'worker-mcp', version: '1.0.0' })
- * // ... later, on teardown:
- * dispose()
- * ```
+ * @param options - The tools, optional identity, and optional port-event gate
+ * @returns The disposer returned by {@link serveMCPScope}
  */
 export declare function serveMCP(options: ServeMCPOptions): () => void;
 
@@ -470,73 +459,17 @@ export declare interface ServeMCPOptions {
 }
 
 /**
- * Boot an `MCPServer` inside a hostable scope (a dedicated Web Worker's `self`, or a
- * Service Worker's `self`) and wire its message events to it.
+ * Boot an `MCPServer` inside a hostable worker scope and wire its message events to it.
  *
  * @remarks
- * **Trust boundary — mechanism, not policy.** `serveMCPScope` exposes the ENTIRE
- * supplied `tools` registry to EVERY client the scope accepts a port from, with NO
- * built-in origin or identity check. In a Service Worker that means every same-origin
- * context the SW controls (any window, worker, or iframe can
- * `controller.postMessage(msg, [port])` and get a fully-bound server with complete
- * tool-call access). Origin allow-listing, handshake tokens, and any other gating are
- * the embedding application's responsibility — compose a guard in front. Use the
- * `accept` option to gate port-bearing events before binding: return `false` to drop
- * the event entirely (no binding, no reply).
- *
- * **Lifetime / per-client binding accumulation.** Each accepted port-bearing event
- * creates a fresh `MessagePortTransport` + `bindServer` binding that lives for the
- * scope's lifetime — there is NO per-client reaping, because `MessagePort` provides
- * no "peer closed" signal. For bounded, long-lived client sets this is fine; embedders
- * with high client churn must track and invoke the dispose function themselves to
- * avoid unbounded accumulation.
- *
- * **Portless events and the implicit scope channel.** A portless `message` event
- * (e.g. `controller.postMessage('<json-rpc>')` in a Service Worker) delivers its
- * string directly to the implicit scope transport — **the tool EXECUTES** — even
- * though no reply can reach the caller. In a `ServiceWorkerGlobalScope` the reply
- * path (`scopeTransport.send` → `scope.postMessage`) throws (no `self.postMessage`),
- * and `bindServer` routes the throw to the server emitter's `error` event (see
- * `@src/core bindServer`), so the un-repliable reply is dropped. The net effect is
- * **blind side-effecting ingress**: the tool runs but the caller gets no result.
- * Crucially, **`accept` does NOT gate this channel** — it is consulted only for
- * port-bearing events. In a Service Worker, if `accept` is your sole guard, ensure
- * all clients connect through transferred `MessagePort`s (port-bearing messages), or
- * restrict the exposed tools to side-effect-free operations, or validate a token
- * inside the tools themselves.
- *
- * Binds the implicit scope channel EAGERLY (at call time, not lazily on first use) —
- * `bindServer` is called once against a {@link import('./types.js').ScopeTransportInterface}
- * wrapping `scope` for the whole lifetime of the returned dispose, so a dedicated
- * worker's very first portless message is served with no first-use setup cost or
- * ordering hazard.
- *
- * Every inbound `message` event is inspected structurally: `event.ports.length > 0`
- * spawns a fresh {@link import('./factories.js').createMessagePortTransport} +
- * `bindServer` for THAT port (tracked for teardown) — this holds even on a
- * dedicated-worker-shaped scope, the unified design's deliberate cross-case. An
- * event with NO ports and a STRING `event.data` is delivered onto the implicit scope
- * channel; any other event (no ports, non-string data) is dropped.
- *
- * @param scope - The hostable scope to wire (structurally, `self` inside a worker)
- * @param options - `tools` (the live registry to expose; REQUIRED), optional
- *   `name`/`version` (default {@link import('./constants.js').DEFAULT_MCP_SERVER_NAME} /
- *   {@link import('./constants.js').DEFAULT_MCP_SERVER_VERSION}), optional `accept`
- *   (origin/identity gate for port-bearing events); see {@link ServeMCPOptions}
- * @returns A dispose function — unbinds every binding, closes every accepted
- *   `MessagePort`, and removes the scope's `message` listener. Idempotent.
- *
- * @example
- * ```ts
- * const scope = { postMessage() {}, addEventListener() {}, removeEventListener() {} }
- * const dispose = serveMCPScope(scope, {
- *   tools: createToolManager(),
- *   // Prefer token-in-data — event.origin is empty for same-origin worker messages.
- *   accept: (event) => event.data === 'my-secret-token',
- * })
- * // ... later:
- * dispose()
- * ```
+ * Port-bearing events are gated by `options.accept`, deduplicated by port, and receive
+ * their own `MessagePortTransport` binding. Portless string events use the scope's
+ * implicit channel. The returned disposer removes the listener, unbinds the implicit
+ * channel, and closes every accepted port binding.
+ *
+ * @param scope - The hostable worker scope to wire
+ * @param options - The tools, optional identity, and optional port-event gate
+ * @returns An idempotent disposer for every binding owned by this call
  */
 export declare function serveMCPScope(scope: ServeMCPScopeInterface, options: ServeMCPOptions): () => void;
 
@@ -549,7 +482,7 @@ export declare function serveMCPScope(scope: ServeMCPScopeInterface, options: Se
  * dedicated-worker implicit reply channel), and `addEventListener` /
  * `removeEventListener` for `'message'` (every inbound event, portless or
  * port-bearing, arrives through the SAME listener — see {@link ServeMCPOptions}'s
- * doc and `serve.ts`). A real `self` / `globalThis` inside a worker satisfies this
+ * doc and the bootstrap factories). A real `self` / `globalThis` inside a worker satisfies this
  * structurally (it exposes far more, which this narrower shape ignores).
  */
 export declare interface ServeMCPScopeInterface {
@@ -602,7 +535,7 @@ export declare class WebSocketClientTransport implements ClientTransportInterfac
     get emitter(): EmitterInterface<ClientTransportEventMap>;
     get session(): string | undefined;
     start(): Promise<void>;
-    send(message: JSONRPCMessage_2 | readonly JSONRPCMessage_2[]): Promise<void>;
+    send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
 

package/dist/src/browser/index.js

@@ -1,5 +1,5 @@
-import { bindServer, createMCPServer, parseJSONRPCMessage } from "../core/index.js";
-import { isString } from "@orkestrel/contract";
+import { SUPPORTED_PROTOCOL_VERSIONS, bindServer, createMCPServer, isJSONRPCResponse, parseJSONRPCMessage } from "../core/index.js";
+import { isRecord, isString } from "@orkestrel/contract";
 import { createSSEParser } from "@orkestrel/sse";
 import { Emitter } from "@orkestrel/emitter";
 //#region src/browser/constants.ts
@@ -11,6 +11,12 @@ import { Emitter } from "@orkestrel/emitter";
 * server unchanged.
 */
 var MCP_SESSION_HEADER = "mcp-session-id";
+/**
+* The Streamable-HTTP transport header carrying the negotiated MCP protocol version
+* on every post-initialize request. The browser HTTP client captures the initialize
+* result's `protocolVersion` and sends this header on each subsequent request.
+*/
+var MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
 /** The default server name `serveMCPScope` reports (`initialize`'s `serverInfo.name`) when `options.name` is omitted. */
 var DEFAULT_MCP_SERVER_NAME = "taverna";
 /** The default server version `serveMCPScope` reports (`initialize`'s `serverInfo.version`) when `options.version` is omitted. */
@@ -183,7 +189,7 @@ async function readEventStream(response) {
 	return messages;
 }
 /**
-* Build `serveMCPScope`'s (`serve.ts`) `message`-event listener — the unified
+* Build `serveMCPScope`'s `message`-event listener — the unified
 * dispatcher that routes EVERY inbound event on a hostable scope, portless or
 * port-bearing, to the right binding.
 *
@@ -225,6 +231,7 @@ function createScopeMessageListener(server, scopeTransport, teardowns, options)
 		if (ports.length > 0) {
 			if (options.accept !== void 0 && !options.accept(event)) return;
 			const port = ports[0];
+			if (port === void 0) return;
 			if (seen.has(port)) return;
 			seen.add(port);
 			const transport = new MessagePortTransport({ port });
@@ -250,7 +257,7 @@ function createScopeMessageListener(server, scopeTransport, teardowns, options)
 *
 * @remarks
 * - **Request/response over `fetch`.** `send(message)` POSTs the JSON-serialized
-*   message (or batch) to `options.url` with `content-type: application/json` and an
+*   message to `options.url` with `content-type: application/json` and an
 *   `Accept` of BOTH `application/json` and `text/event-stream` (so the server may
 *   answer with either framing) — plus any `options.headers` (e.g. an
 *   `Authorization` bearer). It then decodes the reply and emits each decoded
@@ -262,13 +269,18 @@ function createScopeMessageListener(server, scopeTransport, teardowns, options)
 *   face's own `readEventStream`) — the inverse of the server's `openStream` seam, so
 *   the wire round-trips. A `202` Accepted (a notification) carries no body and emits
 *   nothing.
-* - **Session echo.** `start()` / `close()` are no-ops (a request/response transport
-*   holds no long-lived connection). The `mcp-session-id` response header, when a
-*   STATEFUL server sends one (on `initialize`), is captured into `session` and then
-*   ECHOED as the `mcp-session-id` request header on every SUBSEQUENT request — so an
-*   `MCPClient` passes a stateful server's session validation. Before `initialize`
-*   returns an id, `session` is `undefined` and no header is sent (safe against a
-*   stateless server, which neither sends nor expects one).
+* - **Session and protocol echo.** `start()` is a no-op (a
+*   request/response transport opens no long-lived connection). The
+*   `mcp-session-id` response header, when a STATEFUL server sends one (on
+*   `initialize`), is captured into `session` and then ECHOED as the
+*   `mcp-session-id` request header on every SUBSEQUENT request — so an
+*   `MCPClient` passes a stateful server's session validation. The
+*   initialize result's `protocolVersion` is likewise captured, but only
+*   when it is a SUPPORTED value, and echoed as `mcp-protocol-version` on
+*   every subsequent request, as required by the 2025-06-18 Streamable-HTTP
+*   transport. Before initialize returns, neither captured header is sent.
+*   `close()` clears the captured protocol so a reconnect's `initialize`
+*   POST is headerless; the captured `session` persists across `close()`.
 * - **Total at the boundary (§14).** Every reply is narrowed (`parseJSONRPCMessage`,
 *   the SSE decoder) — a non-message reply is dropped, never asserted; a `fetch` /
 *   decode failure surfaces on the `error` event rather than escaping `send`.
@@ -289,11 +301,12 @@ var HTTPClientTransport = class {
 	#fetch;
 	#timeout;
 	#session = void 0;
+	#protocol = void 0;
 	constructor(options) {
 		this.#emitter = new Emitter();
 		this.#url = options.url;
 		this.#headers = options.headers ?? {};
-		this.#fetch = options.fetch ?? globalThis.fetch;
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
 		this.#timeout = options.timeout;
 	}
 	get emitter() {
@@ -312,6 +325,7 @@ var HTTPClientTransport = class {
 					"content-type": "application/json",
 					accept: "application/json, text/event-stream",
 					...this.#session === void 0 ? {} : { [MCP_SESSION_HEADER]: this.#session },
+					...this.#protocol === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: this.#protocol },
 					...this.#headers
 				},
 				body: JSON.stringify(message),
@@ -326,6 +340,7 @@ var HTTPClientTransport = class {
 		await this.#deliver(response);
 	}
 	async close() {
+		this.#protocol = void 0;
 		this.#emitter.emit("close");
 	}
 	async #deliver(response) {
@@ -333,17 +348,21 @@ var HTTPClientTransport = class {
 		const type = response.headers.get("content-type") ?? "";
 		try {
 			if (type.includes("text/event-stream")) {
-				for (const message of await readEventStream(response)) this.#emitter.emit("message", message);
+				for (const message of await readEventStream(response)) this.#capture(message);
 				return;
 			}
 			if (type.includes("application/json")) {
 				const message = parseJSONRPCMessage(await response.json());
-				if (message !== void 0) this.#emitter.emit("message", message);
+				if (message !== void 0) this.#capture(message);
 			}
 		} catch (error) {
 			this.#emitter.emit("error", error);
 		}
 	}
+	#capture(message) {
+		if (isJSONRPCResponse(message) && isRecord(message.result) && isString(message.result["protocolVersion"]) && SUPPORTED_PROTOCOL_VERSIONS.includes(message.result["protocolVersion"])) this.#protocol = message.result["protocolVersion"];
+		this.#emitter.emit("message", message);
+	}
 };
 //#endregion
 //#region src/browser/transports/WebSocketClientTransport.ts
@@ -423,13 +442,10 @@ var WebSocketClientTransport = class {
 	}
 	async send(message) {
 		if (this.#closed) return;
-		const messages = Array.isArray(message) ? message : [message];
-		for (const one of messages) {
-			const text = JSON.stringify(one);
-			const socket = this.#socket;
-			if (socket !== void 0 && socket.readyState === WebSocket.OPEN) socket.send(text);
-			else this.#queue.push(text);
-		}
+		const text = JSON.stringify(message);
+		const socket = this.#socket;
+		if (socket !== void 0 && socket.readyState === WebSocket.OPEN) socket.send(text);
+		else this.#queue.push(text);
 	}
 	async close() {
 		if (this.#closed) return;
@@ -524,8 +540,10 @@ function createWebSocketClientTransport(options) {
 * `message` event for the client's id correlation. Add `options.headers` (e.g. an
 * `Authorization` bearer) to reach a guarded server. `start` / `close` hold no
 * connection; against a STATEFUL server it captures the `mcp-session-id` from
-* `initialize` and echoes it on later requests, so the same `MCPClient` passes
-* session validation (a stateless server sends none).
+* `initialize` and echoes it on later requests. It also captures the initialize
+* result's `protocolVersion` and sends `mcp-protocol-version` on every subsequent
+* request, so the same `MCPClient` passes the session and 2025-06-18 protocol
+* gates without caller wiring.
 *
 * @param options - `url` (the remote endpoint; REQUIRED), optional `headers` merged
 *   onto every request, optional `fetch` (default `globalThis.fetch`), and optional
@@ -580,7 +598,7 @@ function createMessagePortTransport(options) {
 /**
 * Adapt a hostable {@link ServeMCPScopeInterface} (`self` in a dedicated Web Worker,
 * or any structurally matching double) into a {@link ScopeTransportInterface} — the
-* implicit, portless message channel `serveMCPScope` (`serve.ts`) binds for the
+* implicit, portless message channel `serveMCPScope` binds for the
 * dedicated-worker shape.
 *
 * @remarks
@@ -623,76 +641,18 @@ function createScopeTransport(scope) {
 		}
 	};
 }
-//#endregion
-//#region src/browser/serve.ts
 /**
-* Boot an `MCPServer` inside a hostable scope (a dedicated Web Worker's `self`, or a
-* Service Worker's `self`) and wire its message events to it.
+* Boot an `MCPServer` inside a hostable worker scope and wire its message events to it.
 *
 * @remarks
-* **Trust boundary — mechanism, not policy.** `serveMCPScope` exposes the ENTIRE
-* supplied `tools` registry to EVERY client the scope accepts a port from, with NO
-* built-in origin or identity check. In a Service Worker that means every same-origin
-* context the SW controls (any window, worker, or iframe can
-* `controller.postMessage(msg, [port])` and get a fully-bound server with complete
-* tool-call access). Origin allow-listing, handshake tokens, and any other gating are
-* the embedding application's responsibility — compose a guard in front. Use the
-* `accept` option to gate port-bearing events before binding: return `false` to drop
-* the event entirely (no binding, no reply).
-*
-* **Lifetime / per-client binding accumulation.** Each accepted port-bearing event
-* creates a fresh `MessagePortTransport` + `bindServer` binding that lives for the
-* scope's lifetime — there is NO per-client reaping, because `MessagePort` provides
-* no "peer closed" signal. For bounded, long-lived client sets this is fine; embedders
-* with high client churn must track and invoke the dispose function themselves to
-* avoid unbounded accumulation.
-*
-* **Portless events and the implicit scope channel.** A portless `message` event
-* (e.g. `controller.postMessage('<json-rpc>')` in a Service Worker) delivers its
-* string directly to the implicit scope transport — **the tool EXECUTES** — even
-* though no reply can reach the caller. In a `ServiceWorkerGlobalScope` the reply
-* path (`scopeTransport.send` → `scope.postMessage`) throws (no `self.postMessage`),
-* and `bindServer` routes the throw to the server emitter's `error` event (see
-* `@src/core bindServer`), so the un-repliable reply is dropped. The net effect is
-* **blind side-effecting ingress**: the tool runs but the caller gets no result.
-* Crucially, **`accept` does NOT gate this channel** — it is consulted only for
-* port-bearing events. In a Service Worker, if `accept` is your sole guard, ensure
-* all clients connect through transferred `MessagePort`s (port-bearing messages), or
-* restrict the exposed tools to side-effect-free operations, or validate a token
-* inside the tools themselves.
-*
-* Binds the implicit scope channel EAGERLY (at call time, not lazily on first use) —
-* `bindServer` is called once against a {@link import('./types.js').ScopeTransportInterface}
-* wrapping `scope` for the whole lifetime of the returned dispose, so a dedicated
-* worker's very first portless message is served with no first-use setup cost or
-* ordering hazard.
-*
-* Every inbound `message` event is inspected structurally: `event.ports.length > 0`
-* spawns a fresh {@link import('./factories.js').createMessagePortTransport} +
-* `bindServer` for THAT port (tracked for teardown) — this holds even on a
-* dedicated-worker-shaped scope, the unified design's deliberate cross-case. An
-* event with NO ports and a STRING `event.data` is delivered onto the implicit scope
-* channel; any other event (no ports, non-string data) is dropped.
-*
-* @param scope - The hostable scope to wire (structurally, `self` inside a worker)
-* @param options - `tools` (the live registry to expose; REQUIRED), optional
-*   `name`/`version` (default {@link import('./constants.js').DEFAULT_MCP_SERVER_NAME} /
-*   {@link import('./constants.js').DEFAULT_MCP_SERVER_VERSION}), optional `accept`
-*   (origin/identity gate for port-bearing events); see {@link ServeMCPOptions}
-* @returns A dispose function — unbinds every binding, closes every accepted
-*   `MessagePort`, and removes the scope's `message` listener. Idempotent.
-*
-* @example
-* ```ts
-* const scope = { postMessage() {}, addEventListener() {}, removeEventListener() {} }
-* const dispose = serveMCPScope(scope, {
-*   tools: createToolManager(),
-*   // Prefer token-in-data — event.origin is empty for same-origin worker messages.
-*   accept: (event) => event.data === 'my-secret-token',
-* })
-* // ... later:
-* dispose()
-* ```
+* Port-bearing events are gated by `options.accept`, deduplicated by port, and receive
+* their own `MessagePortTransport` binding. Portless string events use the scope's
+* implicit channel. The returned disposer removes the listener, unbinds the implicit
+* channel, and closes every accepted port binding.
+*
+* @param scope - The hostable worker scope to wire
+* @param options - The tools, optional identity, and optional port-event gate
+* @returns An idempotent disposer for every binding owned by this call
 */
 function serveMCPScope(scope, options) {
 	const server = createMCPServer({
@@ -716,40 +676,15 @@ function serveMCPScope(scope, options) {
 	};
 }
 /**
-* Boot an `MCPServer` inside the CURRENT hostable scope (`globalThis` — a dedicated
-* Web Worker or a Service Worker) and wire its message events to it.
-*
-* @remarks
-* A one-liner over {@link serveMCPScope}: `serveMCP(options)` is exactly
-* `serveMCPScope(globalThis, options)`. Kept as its own export so the scope-facing
-* wiring stays independently testable (AGENTS §5) — drive {@link serveMCPScope}
-* directly with a scope double for a test, and this thin wrapper for real deploys.
-*
-* **Trust boundary and lifecycle** — see {@link serveMCPScope}'s `@remarks`. The same
-* considerations apply: ENTIRE tool registry exposed to every accepted port-bearing
-* event; use `accept` to gate; per-client bindings accumulate for the scope's lifetime.
+* Boot an `MCPServer` inside the current hostable worker scope.
 *
-* @param options - `tools` (the live registry to expose; REQUIRED), optional
-*   `name`/`version`, optional `accept` (origin/identity gate); see {@link ServeMCPOptions}
-* @returns A dispose function — see {@link serveMCPScope}
-*
-* @example
-* ```ts
-* // Inside a dedicated Web Worker's entry module:
-* import { serveMCP } from '@orkestrel/mcp/browser'
-* import { createToolManager, createTool } from '@orkestrel/agent'
-*
-* const tools = createToolManager()
-* tools.add(createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
-* const dispose = serveMCP({ tools, name: 'worker-mcp', version: '1.0.0' })
-* // ... later, on teardown:
-* dispose()
-* ```
+* @param options - The tools, optional identity, and optional port-event gate
+* @returns The disposer returned by {@link serveMCPScope}
 */
 function serveMCP(options) {
 	return serveMCPScope(globalThis, options);
 }
 //#endregion
-export { DEFAULT_MCP_SERVER_NAME, DEFAULT_MCP_SERVER_VERSION, HTTPClientTransport, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, MessagePortTransport, WebSocketClientTransport, createHTTPClientTransport, createMessagePortTransport, createScopeMessageListener, createScopeTransport, createWebSocketClientTransport, decodeEvent, readEventStream, serveMCP, serveMCPScope };
+export { DEFAULT_MCP_SERVER_NAME, DEFAULT_MCP_SERVER_VERSION, HTTPClientTransport, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, MessagePortTransport, WebSocketClientTransport, createHTTPClientTransport, createMessagePortTransport, createScopeMessageListener, createScopeTransport, createWebSocketClientTransport, decodeEvent, readEventStream, serveMCP, serveMCPScope };
 
 //# sourceMappingURL=index.js.map