@orkestrel/mcp 0.0.4 → 0.0.5

package/dist/src/server/index.d.cts

@@ -1,12 +1,13 @@
 import { ClientTransportEventMap } from '../core/index.ts';
 import { ClientTransportEventMap as ClientTransportEventMap_2 } from '../../core/index.ts';
-import { ClientTransportInterface } from '../../core/index.ts';
-import { ClientTransportInterface as ClientTransportInterface_2 } from '../core/index.ts';
+import { ClientTransportInterface } from '../core/index.ts';
+import { ClientTransportInterface as ClientTransportInterface_2 } from '../../core/index.ts';
 import { EmitterInterface } from '@orkestrel/emitter';
 import { IncomingMessage } from 'node:http';
 import { JSONRPCMessage } from '../core/index.ts';
 import { JSONRPCMessage as JSONRPCMessage_2 } from '../../core/index.ts';
 import { MCPServerInterface } from '../core/index.ts';
+import { MCPTransportInterface } from '../core/index.ts';
 import { MiddlewareHandler } from '@orkestrel/server';
 import { NodeWebSocketInterface } from '@orkestrel/websocket';
 import { RouteInput } from '@orkestrel/router';
@@ -28,6 +29,49 @@ import { UpgradeHandler } from '@orkestrel/server';
  */
 export declare function acceptsEventStream(request: Request): boolean;
 
+/**
+ * Bridge a message-channel {@link ClientTransportInterface} (the shape the stdio and
+ * WebSocket SERVER transports already implement) into the environment-agnostic
+ * {@link import('@src/core').MCPTransportInterface} port — the adapter
+ * {@link import('./factories.js').createStdioServer} and {@link
+ * import('./factories.js').createWebSocketServer} pipe through `bindServer`, so the
+ * request/reply/error pump those two factories used to hand-roll identically now
+ * lives ONCE in the core binder.
+ *
+ * @remarks
+ * `send` decodes the already-serialized reply string back to a {@link JSONRPCMessage}
+ * and writes it via `transport.send` (the SAME `JSON.stringify` the underlying
+ * transport already performs, so the wire bytes are unchanged). `listen` filters
+ * `transport`'s `message` event to REQUESTS ONLY — a stray response is ignored,
+ * exactly as the prior hand-rolled pumps did — and re-serializes each one back to a
+ * string for `bindServer`. `closed` bridges `transport`'s `close` event. `close`
+ * closes the underlying `transport`.
+ *
+ * @remarks Per {@link import('@src/core').MCPTransportInterface}, `listen`/`closed`
+ * each hold THE SINGLE current handler (a second call REPLACES the first, never adds).
+ * Since the underlying `transport.emitter` is ADD-based (`on` subscribes, never
+ * replaces), this bridge installs ONE stable emitter listener per event on first use
+ * and re-routes it to whichever handler is CURRENTLY registered (`undefined` while
+ * none is), so rebinding never double-dispatches.
+ *
+ * @remarks A response whose `result` serializes away (e.g. `undefined`) is dropped by
+ * the message validators on the wire's decode side — an asymmetry the stdio/WS carrier
+ * shares with the streamable-HTTP face, since both round-trip through `JSON.stringify`
+ * / `JSON.parse` before re-validation.
+ *
+ * @param transport - The message-channel transport to bridge (stdio or WebSocket)
+ * @returns An {@link import('@src/core').MCPTransportInterface} `bindServer` can drive
+ *
+ * @example
+ * ```ts
+ * import { bindServer } from '@src/core'
+ *
+ * const transport = new StdioServerTransport(process.stdin, process.stdout)
+ * bindServer(mcp, bridgeMessageTransport(transport))
+ * ```
+ */
+export declare function bridgeMessageTransport(transport: ClientTransportInterface): MCPTransportInterface;
+
 /**
  * Create the HTTP CLIENT transport for an {@link import('@src/core').MCPClientInterface}
  * — a {@link ClientTransportInterface} that drives a REMOTE Streamable-HTTP MCP server
@@ -61,7 +105,7 @@ export declare function acceptsEventStream(request: Request): boolean;
  * const tools = await client.tools()
  * ```
  */
-export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): ClientTransportInterface_2;
+export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP Streamable-HTTP transport routes — mounts a transport-agnostic
@@ -202,7 +246,7 @@ export declare function createMCPSession<TState extends MCPSessionState>(options
  * const tools = await client.tools()
  * ```
  */
-export declare function createStdioClientTransport(options: StdioClientTransportOptions): ClientTransportInterface_2;
+export declare function createStdioClientTransport(options: StdioClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP stdio transport INGRESS — pumps a transport-agnostic {@link
@@ -212,12 +256,13 @@ export declare function createStdioClientTransport(options: StdioClientTransport
  * @remarks
  * Wraps `options.input` (default `process.stdin`) / `options.output` (default
  * `process.stdout`) in a {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
- * and PUMPS: each inbound {@link import('@src/core').JSONRPCMessage} that is a
- * REQUEST runs through `mcp.dispatch`, and a defined response is written back as a
- * newline-terminated line — a NOTIFICATION (`dispatch` → `undefined`) writes
- * nothing. A non-request message is ignored. The dispatch is guarded so a
- * `dispatch` / `send` fault surfaces on the transport's `error` event rather than
- * escaping the (async) message listener.
+ * and pipes it through the core {@link import('@src/core').MCPTransportInterface} port
+ * via {@link import('./helpers.js').bridgeMessageTransport} + {@link
+ * import('@src/core').bindServer}: each inbound REQUEST runs through `mcp.dispatch`, and
+ * a defined response is written back as a newline-terminated line — a NOTIFICATION
+ * writes nothing, and a non-request message is ignored. A `dispatch` / `send` fault
+ * surfaces on `mcp.emitter`'s `error` event rather than escaping the (async) message
+ * pump.
  *
  * @param mcp - The transport-agnostic {@link MCPServerInterface} to expose over stdio
  * @param options - Optional injectable `input` / `output` streams; see
@@ -270,7 +315,7 @@ export declare function createStdioServer(mcp: MCPServerInterface, options?: Std
  * const tools = await client.tools()
  * ```
  */
-export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): ClientTransportInterface_2;
+export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP WebSocket transport INGRESS — an {@link UpgradeHandler} that exposes a
@@ -290,12 +335,13 @@ export declare function createWebSocketClientTransport(options: WebSocketClientT
  * - **Claims (returns `true`)** otherwise: it builds `createNodeWebSocket({ socket, key, head,
  *   protocol })` (SERVER mode → writes the `101` handshake, echoing the `subprotocol`, default
  *   {@link MCP_WEBSOCKET_SUBPROTOCOL} `'mcp'`, and sends UNMASKED frames), wraps it in a
- *   {@link WebSocketServerTransport}, and PUMPS: each inbound {@link
- *   import('@src/core').JSONRPCMessage} that is a REQUEST runs through `mcp.dispatch`, and a
- *   defined response is written back as a frame — a NOTIFICATION (`dispatch` → `undefined`)
- *   sends nothing. A non-request message (a stray response) is ignored. The dispatch is
- *   guarded so a `dispatch` / `send` fault surfaces on the transport's `error` event rather
- *   than escaping the (async) message listener.
+ *   {@link WebSocketServerTransport}, and pipes it through the core {@link
+ *   import('@src/core').MCPTransportInterface} port via {@link
+ *   import('./helpers.js').bridgeMessageTransport} + {@link import('@src/core').bindServer}:
+ *   each inbound REQUEST runs through `mcp.dispatch`, and a defined response is written back
+ *   as a frame — a NOTIFICATION sends nothing, and a non-request message (a stray response) is
+ *   ignored. A `dispatch` / `send` fault surfaces on `mcp.emitter`'s `error` event rather than
+ *   escaping the (async) message pump.
  *
  * It is MECHANISM, not policy: compose an auth guard IN FRONT by registering an upgrade
  * handler BEFORE this one — that handler can claim (decline + destroy) an unauthenticated
@@ -454,7 +500,7 @@ export declare function extractLines(buffer: string, chunk: string): LineExtract
  * await client.connect()
  * ```
  */
-export declare class HTTPClientTransport implements ClientTransportInterface {
+export declare class HTTPClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: HTTPClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -814,7 +860,7 @@ export declare function rejectUnknownSession(): Response;
  * await client.connect() // start() spawns the child, then the MCP initialize runs over stdio
  * ```
  */
-export declare class StdioClientTransport implements ClientTransportInterface {
+export declare class StdioClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: StdioClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -886,7 +932,7 @@ export declare interface StdioServerOptions {
  *   emitter isolates a listener throw; `error` is a DOMAIN event (a transport-level
  *   fault), distinct from the emitter's own listener-error channel.
  */
-export declare class StdioServerTransport implements ClientTransportInterface {
+export declare class StdioServerTransport implements ClientTransportInterface_2 {
     #private;
     constructor(input: NodeJS.ReadableStream, output: NodeJS.WritableStream);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -949,7 +995,7 @@ export declare function upgradeRequestPath(request: IncomingMessage): string;
  * await client.connect() // start() handshakes, then the MCP initialize runs over WS frames
  * ```
  */
-export declare class WebSocketClientTransport implements ClientTransportInterface {
+export declare class WebSocketClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: WebSocketClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -1031,7 +1077,7 @@ export declare interface WebSocketServerOptions {
  *   isolates a listener throw (a buggy observer never corrupts the bridge). `error` is a
  *   DOMAIN event (a transport-level fault), distinct from the emitter's listener-error channel.
  */
-export declare class WebSocketServerTransport implements ClientTransportInterface {
+export declare class WebSocketServerTransport implements ClientTransportInterface_2 {
     #private;
     constructor(socket: NodeWebSocketInterface);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;

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

@@ -1,12 +1,13 @@
 import { ClientTransportEventMap } from '../core/index.ts';
 import { ClientTransportEventMap as ClientTransportEventMap_2 } from '../../core/index.ts';
-import { ClientTransportInterface } from '../../core/index.ts';
-import { ClientTransportInterface as ClientTransportInterface_2 } from '../core/index.ts';
+import { ClientTransportInterface } from '../core/index.ts';
+import { ClientTransportInterface as ClientTransportInterface_2 } from '../../core/index.ts';
 import { EmitterInterface } from '@orkestrel/emitter';
 import { IncomingMessage } from 'node:http';
 import { JSONRPCMessage } from '../core/index.ts';
 import { JSONRPCMessage as JSONRPCMessage_2 } from '../../core/index.ts';
 import { MCPServerInterface } from '../core/index.ts';
+import { MCPTransportInterface } from '../core/index.ts';
 import { MiddlewareHandler } from '@orkestrel/server';
 import { NodeWebSocketInterface } from '@orkestrel/websocket';
 import { RouteInput } from '@orkestrel/router';
@@ -28,6 +29,49 @@ import { UpgradeHandler } from '@orkestrel/server';
  */
 export declare function acceptsEventStream(request: Request): boolean;
 
+/**
+ * Bridge a message-channel {@link ClientTransportInterface} (the shape the stdio and
+ * WebSocket SERVER transports already implement) into the environment-agnostic
+ * {@link import('@src/core').MCPTransportInterface} port — the adapter
+ * {@link import('./factories.js').createStdioServer} and {@link
+ * import('./factories.js').createWebSocketServer} pipe through `bindServer`, so the
+ * request/reply/error pump those two factories used to hand-roll identically now
+ * lives ONCE in the core binder.
+ *
+ * @remarks
+ * `send` decodes the already-serialized reply string back to a {@link JSONRPCMessage}
+ * and writes it via `transport.send` (the SAME `JSON.stringify` the underlying
+ * transport already performs, so the wire bytes are unchanged). `listen` filters
+ * `transport`'s `message` event to REQUESTS ONLY — a stray response is ignored,
+ * exactly as the prior hand-rolled pumps did — and re-serializes each one back to a
+ * string for `bindServer`. `closed` bridges `transport`'s `close` event. `close`
+ * closes the underlying `transport`.
+ *
+ * @remarks Per {@link import('@src/core').MCPTransportInterface}, `listen`/`closed`
+ * each hold THE SINGLE current handler (a second call REPLACES the first, never adds).
+ * Since the underlying `transport.emitter` is ADD-based (`on` subscribes, never
+ * replaces), this bridge installs ONE stable emitter listener per event on first use
+ * and re-routes it to whichever handler is CURRENTLY registered (`undefined` while
+ * none is), so rebinding never double-dispatches.
+ *
+ * @remarks A response whose `result` serializes away (e.g. `undefined`) is dropped by
+ * the message validators on the wire's decode side — an asymmetry the stdio/WS carrier
+ * shares with the streamable-HTTP face, since both round-trip through `JSON.stringify`
+ * / `JSON.parse` before re-validation.
+ *
+ * @param transport - The message-channel transport to bridge (stdio or WebSocket)
+ * @returns An {@link import('@src/core').MCPTransportInterface} `bindServer` can drive
+ *
+ * @example
+ * ```ts
+ * import { bindServer } from '@src/core'
+ *
+ * const transport = new StdioServerTransport(process.stdin, process.stdout)
+ * bindServer(mcp, bridgeMessageTransport(transport))
+ * ```
+ */
+export declare function bridgeMessageTransport(transport: ClientTransportInterface): MCPTransportInterface;
+
 /**
  * Create the HTTP CLIENT transport for an {@link import('@src/core').MCPClientInterface}
  * — a {@link ClientTransportInterface} that drives a REMOTE Streamable-HTTP MCP server
@@ -61,7 +105,7 @@ export declare function acceptsEventStream(request: Request): boolean;
  * const tools = await client.tools()
  * ```
  */
-export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): ClientTransportInterface_2;
+export declare function createHTTPClientTransport(options: HTTPClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP Streamable-HTTP transport routes — mounts a transport-agnostic
@@ -202,7 +246,7 @@ export declare function createMCPSession<TState extends MCPSessionState>(options
  * const tools = await client.tools()
  * ```
  */
-export declare function createStdioClientTransport(options: StdioClientTransportOptions): ClientTransportInterface_2;
+export declare function createStdioClientTransport(options: StdioClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP stdio transport INGRESS — pumps a transport-agnostic {@link
@@ -212,12 +256,13 @@ export declare function createStdioClientTransport(options: StdioClientTransport
  * @remarks
  * Wraps `options.input` (default `process.stdin`) / `options.output` (default
  * `process.stdout`) in a {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
- * and PUMPS: each inbound {@link import('@src/core').JSONRPCMessage} that is a
- * REQUEST runs through `mcp.dispatch`, and a defined response is written back as a
- * newline-terminated line — a NOTIFICATION (`dispatch` → `undefined`) writes
- * nothing. A non-request message is ignored. The dispatch is guarded so a
- * `dispatch` / `send` fault surfaces on the transport's `error` event rather than
- * escaping the (async) message listener.
+ * and pipes it through the core {@link import('@src/core').MCPTransportInterface} port
+ * via {@link import('./helpers.js').bridgeMessageTransport} + {@link
+ * import('@src/core').bindServer}: each inbound REQUEST runs through `mcp.dispatch`, and
+ * a defined response is written back as a newline-terminated line — a NOTIFICATION
+ * writes nothing, and a non-request message is ignored. A `dispatch` / `send` fault
+ * surfaces on `mcp.emitter`'s `error` event rather than escaping the (async) message
+ * pump.
  *
  * @param mcp - The transport-agnostic {@link MCPServerInterface} to expose over stdio
  * @param options - Optional injectable `input` / `output` streams; see
@@ -270,7 +315,7 @@ export declare function createStdioServer(mcp: MCPServerInterface, options?: Std
  * const tools = await client.tools()
  * ```
  */
-export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): ClientTransportInterface_2;
+export declare function createWebSocketClientTransport(options: WebSocketClientTransportOptions): ClientTransportInterface;
 
 /**
  * Create the MCP WebSocket transport INGRESS — an {@link UpgradeHandler} that exposes a
@@ -290,12 +335,13 @@ export declare function createWebSocketClientTransport(options: WebSocketClientT
  * - **Claims (returns `true`)** otherwise: it builds `createNodeWebSocket({ socket, key, head,
  *   protocol })` (SERVER mode → writes the `101` handshake, echoing the `subprotocol`, default
  *   {@link MCP_WEBSOCKET_SUBPROTOCOL} `'mcp'`, and sends UNMASKED frames), wraps it in a
- *   {@link WebSocketServerTransport}, and PUMPS: each inbound {@link
- *   import('@src/core').JSONRPCMessage} that is a REQUEST runs through `mcp.dispatch`, and a
- *   defined response is written back as a frame — a NOTIFICATION (`dispatch` → `undefined`)
- *   sends nothing. A non-request message (a stray response) is ignored. The dispatch is
- *   guarded so a `dispatch` / `send` fault surfaces on the transport's `error` event rather
- *   than escaping the (async) message listener.
+ *   {@link WebSocketServerTransport}, and pipes it through the core {@link
+ *   import('@src/core').MCPTransportInterface} port via {@link
+ *   import('./helpers.js').bridgeMessageTransport} + {@link import('@src/core').bindServer}:
+ *   each inbound REQUEST runs through `mcp.dispatch`, and a defined response is written back
+ *   as a frame — a NOTIFICATION sends nothing, and a non-request message (a stray response) is
+ *   ignored. A `dispatch` / `send` fault surfaces on `mcp.emitter`'s `error` event rather than
+ *   escaping the (async) message pump.
  *
  * It is MECHANISM, not policy: compose an auth guard IN FRONT by registering an upgrade
  * handler BEFORE this one — that handler can claim (decline + destroy) an unauthenticated
@@ -454,7 +500,7 @@ export declare function extractLines(buffer: string, chunk: string): LineExtract
  * await client.connect()
  * ```
  */
-export declare class HTTPClientTransport implements ClientTransportInterface {
+export declare class HTTPClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: HTTPClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -814,7 +860,7 @@ export declare function rejectUnknownSession(): Response;
  * await client.connect() // start() spawns the child, then the MCP initialize runs over stdio
  * ```
  */
-export declare class StdioClientTransport implements ClientTransportInterface {
+export declare class StdioClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: StdioClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -886,7 +932,7 @@ export declare interface StdioServerOptions {
  *   emitter isolates a listener throw; `error` is a DOMAIN event (a transport-level
  *   fault), distinct from the emitter's own listener-error channel.
  */
-export declare class StdioServerTransport implements ClientTransportInterface {
+export declare class StdioServerTransport implements ClientTransportInterface_2 {
     #private;
     constructor(input: NodeJS.ReadableStream, output: NodeJS.WritableStream);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -949,7 +995,7 @@ export declare function upgradeRequestPath(request: IncomingMessage): string;
  * await client.connect() // start() handshakes, then the MCP initialize runs over WS frames
  * ```
  */
-export declare class WebSocketClientTransport implements ClientTransportInterface {
+export declare class WebSocketClientTransport implements ClientTransportInterface_2 {
     #private;
     constructor(options: WebSocketClientTransportOptions);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;
@@ -1031,7 +1077,7 @@ export declare interface WebSocketServerOptions {
  *   isolates a listener throw (a buggy observer never corrupts the bridge). `error` is a
  *   DOMAIN event (a transport-level fault), distinct from the emitter's listener-error channel.
  */
-export declare class WebSocketServerTransport implements ClientTransportInterface {
+export declare class WebSocketServerTransport implements ClientTransportInterface_2 {
     #private;
     constructor(socket: NodeWebSocketInterface);
     get emitter(): EmitterInterface<ClientTransportEventMap_2>;

package/dist/src/server/index.js

@@ -1,5 +1,5 @@
 import { createSSEParser } from "@orkestrel/sse";
-import { JSONRPC_INVALID_REQUEST, JSONRPC_PARSE_ERROR, isInitializeRequest, isJSONRPCRequest, jsonRPCError, parseJSONRPCMessage } from "../core/index.js";
+import { JSONRPC_INVALID_REQUEST, JSONRPC_PARSE_ERROR, bindServer, isInitializeRequest, isJSONRPCRequest, jsonRPCError, parseJSONRPCMessage } from "../core/index.js";
 import { isString } from "@orkestrel/contract";
 import { Emitter } from "@orkestrel/emitter";
 import { randomBytes } from "node:crypto";
@@ -263,6 +263,81 @@ function dispatchLines(emitter, lines) {
 		emitter.emit("message", message);
 	}
 }
+/**
+* Bridge a message-channel {@link ClientTransportInterface} (the shape the stdio and
+* WebSocket SERVER transports already implement) into the environment-agnostic
+* {@link import('@src/core').MCPTransportInterface} port — the adapter
+* {@link import('./factories.js').createStdioServer} and {@link
+* import('./factories.js').createWebSocketServer} pipe through `bindServer`, so the
+* request/reply/error pump those two factories used to hand-roll identically now
+* lives ONCE in the core binder.
+*
+* @remarks
+* `send` decodes the already-serialized reply string back to a {@link JSONRPCMessage}
+* and writes it via `transport.send` (the SAME `JSON.stringify` the underlying
+* transport already performs, so the wire bytes are unchanged). `listen` filters
+* `transport`'s `message` event to REQUESTS ONLY — a stray response is ignored,
+* exactly as the prior hand-rolled pumps did — and re-serializes each one back to a
+* string for `bindServer`. `closed` bridges `transport`'s `close` event. `close`
+* closes the underlying `transport`.
+*
+* @remarks Per {@link import('@src/core').MCPTransportInterface}, `listen`/`closed`
+* each hold THE SINGLE current handler (a second call REPLACES the first, never adds).
+* Since the underlying `transport.emitter` is ADD-based (`on` subscribes, never
+* replaces), this bridge installs ONE stable emitter listener per event on first use
+* and re-routes it to whichever handler is CURRENTLY registered (`undefined` while
+* none is), so rebinding never double-dispatches.
+*
+* @remarks A response whose `result` serializes away (e.g. `undefined`) is dropped by
+* the message validators on the wire's decode side — an asymmetry the stdio/WS carrier
+* shares with the streamable-HTTP face, since both round-trip through `JSON.stringify`
+* / `JSON.parse` before re-validation.
+*
+* @param transport - The message-channel transport to bridge (stdio or WebSocket)
+* @returns An {@link import('@src/core').MCPTransportInterface} `bindServer` can drive
+*
+* @example
+* ```ts
+* import { bindServer } from '@src/core'
+*
+* const transport = new StdioServerTransport(process.stdin, process.stdout)
+* bindServer(mcp, bridgeMessageTransport(transport))
+* ```
+*/
+function bridgeMessageTransport(transport) {
+	let onMessage;
+	let onClosed;
+	let subscribed = false;
+	function subscribe() {
+		if (subscribed) return;
+		subscribed = true;
+		transport.emitter.on("message", (message) => {
+			if (!isJSONRPCRequest(message)) return;
+			onMessage?.(JSON.stringify(message));
+		});
+		transport.emitter.on("close", () => {
+			onClosed?.();
+		});
+	}
+	return {
+		async send(message) {
+			const decoded = decodeEvent(message);
+			if (decoded === void 0) return;
+			await transport.send(decoded);
+		},
+		listen(handler) {
+			subscribe();
+			onMessage = handler;
+		},
+		closed(handler) {
+			subscribe();
+			onClosed = handler;
+		},
+		async close() {
+			await transport.close();
+		}
+	};
+}
 //#endregion
 //#region src/server/transports/HTTPClientTransport.ts
 /**
@@ -1030,12 +1105,13 @@ function createHTTPClientTransport(options) {
 * - **Claims (returns `true`)** otherwise: it builds `createNodeWebSocket({ socket, key, head,
 *   protocol })` (SERVER mode → writes the `101` handshake, echoing the `subprotocol`, default
 *   {@link MCP_WEBSOCKET_SUBPROTOCOL} `'mcp'`, and sends UNMASKED frames), wraps it in a
-*   {@link WebSocketServerTransport}, and PUMPS: each inbound {@link
-*   import('@src/core').JSONRPCMessage} that is a REQUEST runs through `mcp.dispatch`, and a
-*   defined response is written back as a frame — a NOTIFICATION (`dispatch` → `undefined`)
-*   sends nothing. A non-request message (a stray response) is ignored. The dispatch is
-*   guarded so a `dispatch` / `send` fault surfaces on the transport's `error` event rather
-*   than escaping the (async) message listener.
+*   {@link WebSocketServerTransport}, and pipes it through the core {@link
+*   import('@src/core').MCPTransportInterface} port via {@link
+*   import('./helpers.js').bridgeMessageTransport} + {@link import('@src/core').bindServer}:
+*   each inbound REQUEST runs through `mcp.dispatch`, and a defined response is written back
+*   as a frame — a NOTIFICATION sends nothing, and a non-request message (a stray response) is
+*   ignored. A `dispatch` / `send` fault surfaces on `mcp.emitter`'s `error` event rather than
+*   escaping the (async) message pump.
 *
 * It is MECHANISM, not policy: compose an auth guard IN FRONT by registering an upgrade
 * handler BEFORE this one — that handler can claim (decline + destroy) an unauthenticated
@@ -1072,19 +1148,7 @@ function createWebSocketServer(mcp, options) {
 			head,
 			protocol: subprotocol
 		}));
-		transport.emitter.on("message", (message) => {
-			if (!isJSONRPCRequest(message)) return;
-			(async () => {
-				try {
-					const response = await mcp.dispatch(message);
-					if (response !== void 0) await transport.send(response);
-				} catch (error) {
-					try {
-						transport.emitter.emit("error", error);
-					} catch {}
-				}
-			})();
-		});
+		bindServer(mcp, bridgeMessageTransport(transport));
 		transport.start();
 		return true;
 	};
@@ -1166,12 +1230,13 @@ function createStdioClientTransport(options) {
 * @remarks
 * Wraps `options.input` (default `process.stdin`) / `options.output` (default
 * `process.stdout`) in a {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
-* and PUMPS: each inbound {@link import('@src/core').JSONRPCMessage} that is a
-* REQUEST runs through `mcp.dispatch`, and a defined response is written back as a
-* newline-terminated line — a NOTIFICATION (`dispatch` → `undefined`) writes
-* nothing. A non-request message is ignored. The dispatch is guarded so a
-* `dispatch` / `send` fault surfaces on the transport's `error` event rather than
-* escaping the (async) message listener.
+* and pipes it through the core {@link import('@src/core').MCPTransportInterface} port
+* via {@link import('./helpers.js').bridgeMessageTransport} + {@link
+* import('@src/core').bindServer}: each inbound REQUEST runs through `mcp.dispatch`, and
+* a defined response is written back as a newline-terminated line — a NOTIFICATION
+* writes nothing, and a non-request message is ignored. A `dispatch` / `send` fault
+* surfaces on `mcp.emitter`'s `error` event rather than escaping the (async) message
+* pump.
 *
 * @param mcp - The transport-agnostic {@link MCPServerInterface} to expose over stdio
 * @param options - Optional injectable `input` / `output` streams; see
@@ -1189,19 +1254,7 @@ function createStdioClientTransport(options) {
 */
 function createStdioServer(mcp, options) {
 	const transport = new StdioServerTransport(options?.input ?? process.stdin, options?.output ?? process.stdout);
-	transport.emitter.on("message", (message) => {
-		if (!isJSONRPCRequest(message)) return;
-		(async () => {
-			try {
-				const response = await mcp.dispatch(message);
-				if (response !== void 0) await transport.send(response);
-			} catch (error) {
-				try {
-					transport.emitter.emit("error", error);
-				} catch {}
-			}
-		})();
-	});
+	bindServer(mcp, bridgeMessageTransport(transport));
 	return {
 		start() {
 			transport.start();
@@ -1339,6 +1392,6 @@ function createMCPSession(options) {
 	}
 }
 //#endregion
-export { DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, MCPSession, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, createHTTPClientTransport, createMCPRoutes, createMCPSession, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, upgradeRequestPath };
+export { DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, MCPSession, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, bridgeMessageTransport, createHTTPClientTransport, createMCPRoutes, createMCPSession, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, upgradeRequestPath };
 
 //# sourceMappingURL=index.js.map