@modelcontextprotocol/server 2.0.0-alpha.3 → 2.0.0-beta.1

package/dist/shimsNode.d.mts

@@ -1,3 +1,3 @@
-import { t as AjvJsonSchemaValidator } from "./ajvProvider-DZ_siXcF.mjs";
+import { t as AjvJsonSchemaValidator } from "./ajvProvider-Dzgk80kq.mjs";
 import process from "node:process";
 export { AjvJsonSchemaValidator as DefaultJsonSchemaValidator, process };

package/dist/shimsNode.mjs

@@ -1,4 +1,4 @@
-import { t as AjvJsonSchemaValidator } from "./ajvProvider-Birb50r-.mjs";
+import { t as AjvJsonSchemaValidator } from "./ajvProvider-BQMcjynJ.mjs";
 import process from "node:process";
 
 export { AjvJsonSchemaValidator as DefaultJsonSchemaValidator, process };

package/dist/shimsWorkerd.d.mts

@@ -1,4 +1,4 @@
-import { t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-DUhk5Ewx.mjs";
+import { t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-DmvjVsvQ.mjs";
 
 //#region src/shimsWorkerd.d.ts
 

package/dist/shimsWorkerd.mjs

@@ -1,4 +1,4 @@
-import { t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-BrJKpSFH.mjs";
+import { t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-BDC2rVl3.mjs";
 
 //#region src/shimsWorkerd.ts
 /**

package/dist/stdio.d.mts

@@ -1,8 +1,66 @@
-import { gt as JSONRPCMessage, n as Transport } from "./transport-DMKhEchd.mjs";
+import { cr as JSONRPCMessage, o as McpServerFactory, rt as Transport } from "./createMcpHandler-Du3hjXvf.mjs";
 import { Readable, Writable } from "node:stream";
 
-//#region src/server/stdio.d.ts
+//#region src/server/serveStdio.d.ts
 
+/** Options for {@linkcode serveStdio}. */
+interface ServeStdioOptions {
+  /**
+   * How a 2025-era opening (an `initialize` request, or any claim-less
+   * message) is handled:
+   *
+   * - `'serve'` (default) — the connection is pinned to a 2025-era instance
+   *   from the same factory and served exactly as a hand-wired stdio server
+   *   serves it today.
+   * - `'reject'` — the opening request is answered with the
+   *   unsupported-protocol-version error naming the supported modern
+   *   revisions (claim-less notifications are dropped); the connection
+   *   stays open for a modern opening.
+   */
+  legacy?: 'serve' | 'reject';
+  /**
+   * Bring your own transport (for example a `StdioServerTransport`
+   * constructed over a Unix domain socket or TCP stream, per the stdio
+   * binding's custom-transport guidance). Defaults to a
+   * {@linkcode StdioServerTransport} over the current process's stdio. The
+   * entry owns the transport: it starts it, receives every inbound message,
+   * and closes it when the connection ends.
+   */
+  transport?: Transport;
+  /** Callback for out-of-band errors (reporting only; it never alters what is written to the wire). */
+  onerror?: (error: Error) => void;
+  /**
+   * Reject a new `subscriptions/listen` with `-32603` 'Subscription limit
+   * reached' (in-band, before the ack) when this many subscriptions are
+   * already open on this connection.
+   * @default 1024
+   */
+  maxSubscriptions?: number;
+}
+/** The handle returned by {@linkcode serveStdio}. */
+interface StdioServerHandle {
+  /** Tears the connection down: closes the pinned instance (if any) and the underlying transport. */
+  close(): Promise<void>;
+}
+/**
+ * Serves MCP over stdio from a server factory, owning the era decision for
+ * the connection: the opening exchange selects the era, ONE instance from the
+ * factory is pinned for the connection lifetime, and everything after passes
+ * straight through to it. See the module documentation for the opening rules.
+ *
+ * ```ts
+ * import { serveStdio } from '@modelcontextprotocol/server/stdio';
+ *
+ * serveStdio(() => {
+ *     const server = new McpServer({ name: 'my-server', version: '1.0.0' }, { capabilities: { tools: {} } });
+ *     // register tools/resources/prompts once — the same factory serves both eras
+ *     return server;
+ * });
+ * ```
+ */
+declare function serveStdio(factory: McpServerFactory, options?: ServeStdioOptions): StdioServerHandle;
+//#endregion
+//#region src/server/stdio.d.ts
 /**
  * Server transport for stdio: this communicates with an MCP client by reading from the current process' `stdin` and writing to `stdout`.
  *
@@ -45,5 +103,5 @@ declare class StdioServerTransport implements Transport {
   send(message: JSONRPCMessage): Promise<void>;
 }
 //#endregion
-export { StdioServerTransport };
+export { type ServeStdioOptions, type StdioServerHandle, StdioServerTransport, serveStdio };
 //# sourceMappingURL=stdio.d.mts.map

package/dist/stdio.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.mts","names":[],"sources":["../src/server/stdio.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkBA;;;;;;;;;;AAoGkB,cApGL,oBAAA,YAAgC,SAoG3B,CAAA;EAAiB,QAAA,MAAA;EApGU,QAAA,OAAA;EAAS,QAAA,WAAA;;;uBAM9B,oBACC;;;;;;;;;;oBAeH;wBACI;mBAGJ;oBASC;0BAGM;;;;WAUV;;WA4BA;gBAwBD,iBAAiB"}
+{"version":3,"file":"stdio.d.mts","names":[],"sources":["../src/server/serveStdio.ts","../src/server/stdio.ts"],"sourcesContent":[],"mappings":";;;;;;UAoFiB,iBAAA;;;;;;;;;;;;;;;;;;;;;;cAsBD;;oBAEM;;;;;;;;;;UAWL,iBAAA;;WAEJ;;;;;;;;;;;;;;;;;;iBA6PG,UAAA,UAAoB,4BAA2B,oBAAyB;;;;;AAlSxF;AAmCA;AA+PA;;;;;;;;ACpWa,cAAA,oBAAA,YAAgC,SAAX,CAAA;EAMV,QAAA,MAAA;EACC,QAAA,OAAA;EAeH,QAAA,WAAA;EACI,QAAA,QAAA;EAGJ,QAAA,OAAA;EASC,WAAA,CAAA,MAAA,CAAA,EA7BC,QA6BD,EAAA,OAAA,CAAA,EA5BE,QA4BF,EAAA,QAAA,EAAA;IAGM;;;;;;IAtCyB,aAAA,CAAA,EAAA,MAAA;;;oBAsBhC;wBACI;mBAGJ;oBASC;0BAGM;;;;WAUV;;WA4BA;gBAwBD,iBAAiB"}

package/dist/stdio.mjs

@@ -1,4 +1,4 @@
-import { c as ReadBuffer, d as serializeMessage } from "./src-Pa1iAvsj.mjs";
+import { $ as validateEnvelopeMeta, H as isJSONRPCErrorResponse, K as isJSONRPCResultResponse, M as modernOnlyStrictRejection, Q as requestMetaOf, S as setNegotiatedProtocolVersion, U as isJSONRPCNotification, W as isJSONRPCRequest, X as envelopeClaimVersion, Z as hasEnvelopeClaim, at as ProtocolErrorCode, c as StdioListenRouter, g as ReadBuffer, i as installModernOnlyHandlers, k as carriesValidModernEnvelopeClaim, ot as SUPPORTED_MODERN_PROTOCOL_VERSIONS, rt as UnsupportedProtocolVersionError, s as DEFAULT_MAX_SUBSCRIPTIONS, t as McpServer, y as serializeMessage } from "./mcp-JttQJlI9.mjs";
 import { process } from "@modelcontextprotocol/server/_shims";
 
 //#region src/server/stdio.ts
@@ -102,5 +102,460 @@ var StdioServerTransport = class {
 };
 
 //#endregion
-export { StdioServerTransport };
+//#region src/server/serveStdio.ts
+/**
+* How long the probe-discard path waits for the probe instance to answer the
+* requests it was delivered before closing it. The wait normally settles as
+* soon as the DiscoverResult is handed to the wire (or immediately, when a
+* delivered cancellation already settled the probe); the bound is a backstop
+* so no edge can ever hold the connection's inbound pump indefinitely behind
+* the discard.
+*/
+const DISCARD_ANSWER_TIMEOUT_MS = 3e3;
+/**
+* The transport a pinned instance is connected to: a thin channel that writes
+* through to the entry-owned wire transport and receives the messages the
+* entry forwards. The wire transport itself is never handed to an instance —
+* that is what lets the entry discard an optimistic probe instance (close the
+* channel) without tearing down the connection.
+*/
+var StdioConnectionChannel = class {
+	onclose;
+	onerror;
+	onmessage;
+	_closed = false;
+	/** Request ids the entry delivered to the instance that the instance has not yet answered. */
+	_pendingRequests = /* @__PURE__ */ new Set();
+	_drainWaiters = [];
+	constructor(_wire, _onInstanceClose, _outboundIntercept) {
+		this._wire = _wire;
+		this._onInstanceClose = _onInstanceClose;
+		this._outboundIntercept = _outboundIntercept;
+	}
+	async start() {}
+	async send(message, options) {
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+			const { id } = message;
+			if (id !== void 0) this._settle(id);
+		}
+		if (this._closed) return;
+		if (this._outboundIntercept?.(message) === "handled") return;
+		return this._wire.send(message, options);
+	}
+	setProtocolVersion = (version) => {
+		this._wire.setProtocolVersion?.(version);
+	};
+	/** Forwards one inbound message to the connected instance. */
+	deliver(message, extra) {
+		if (this._closed) return;
+		if (isJSONRPCRequest(message)) this._pendingRequests.add(message.id);
+		else if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+			const cancelledId = message.params?.requestId;
+			if (cancelledId !== void 0) this._settle(cancelledId);
+		}
+		this.onmessage?.(message, extra);
+	}
+	/**
+	* Resolves once every request delivered to the instance has been answered
+	* through {@linkcode send}, settled by a delivered cancellation, or the
+	* channel has been closed and nothing further can be answered. The wait is
+	* bounded by `timeoutMs` as a backstop so no edge can hold the caller
+	* indefinitely; resolves `false` only when the bound elapsed with requests
+	* still unanswered. Used by the probe-discard path so a probe request the
+	* entry accepted is never silently dropped.
+	*/
+	async whenRequestsAnswered(timeoutMs) {
+		if (this._closed || this._pendingRequests.size === 0) return true;
+		return await new Promise((resolve) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolve(true);
+			};
+			const timer = setTimeout(() => {
+				this._drainWaiters = this._drainWaiters.filter((pending) => pending !== waiter);
+				resolve(false);
+			}, timeoutMs);
+			this._drainWaiters.push(waiter);
+		});
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._pendingRequests.clear();
+		this._releaseDrainWaiters();
+		try {
+			this._onInstanceClose();
+		} finally {
+			this.onclose?.();
+		}
+	}
+	_settle(id) {
+		this._pendingRequests.delete(id);
+		if (this._pendingRequests.size === 0) this._releaseDrainWaiters();
+	}
+	_releaseDrainWaiters() {
+		const waiters = this._drainWaiters;
+		this._drainWaiters = [];
+		for (const waiter of waiters) waiter();
+	}
+};
+/**
+* Classifies one message of the opening exchange with the same body-primary
+* rules the HTTP entry applies per request: `initialize` is the legacy
+* handshake unless it carries a valid modern envelope claim; a present claim
+* is validated (never silently ignored); a claim-less message is 2025-era
+* traffic. There is no header layer on stdio, so the body is the only signal.
+*/
+function classifyOpeningMessage(message) {
+	const params = message.params;
+	if (message.method === "initialize" && !carriesValidModernEnvelopeClaim(params)) {
+		const requestedVersion = params !== null && typeof params === "object" && typeof params.protocolVersion === "string" ? params.protocolVersion : void 0;
+		return {
+			kind: "legacy",
+			reason: "initialize",
+			...requestedVersion !== void 0 && { requestedVersion }
+		};
+	}
+	if (!hasEnvelopeClaim(params)) return {
+		kind: "legacy",
+		reason: "no-claim"
+	};
+	const meta = requestMetaOf(params);
+	const firstIssue = (meta === void 0 ? [] : validateEnvelopeMeta(meta))[0];
+	if (firstIssue !== void 0) return {
+		kind: "invalid-envelope",
+		issue: firstIssue
+	};
+	const claimedVersion = envelopeClaimVersion(params);
+	if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) return {
+		kind: "unsupported-revision",
+		requested: claimedVersion ?? "unknown"
+	};
+	return {
+		kind: "modern",
+		revision: claimedVersion,
+		classification: {
+			era: "modern",
+			revision: claimedVersion
+		}
+	};
+}
+/**
+* Serves MCP over stdio from a server factory, owning the era decision for
+* the connection: the opening exchange selects the era, ONE instance from the
+* factory is pinned for the connection lifetime, and everything after passes
+* straight through to it. See the module documentation for the opening rules.
+*
+* ```ts
+* import { serveStdio } from '@modelcontextprotocol/server/stdio';
+*
+* serveStdio(() => {
+*     const server = new McpServer({ name: 'my-server', version: '1.0.0' }, { capabilities: { tools: {} } });
+*     // register tools/resources/prompts once — the same factory serves both eras
+*     return server;
+* });
+* ```
+*/
+function serveStdio(factory, options = {}) {
+	const legacyMode = options.legacy ?? "serve";
+	const wire = options.transport ?? new StdioServerTransport();
+	let state = { phase: "opening" };
+	/** Channel currently being discarded (its close must not tear the connection down). */
+	let discarding;
+	let closing = false;
+	/**
+	* Whether the connection has been torn down (`handle.close()` or the wire
+	* closing). The opening arms re-check this after every await: a close can
+	* race factory construction, and the continuation must neither resurrect
+	* the connection state nor keep a late-resolved instance around.
+	*/
+	const isTornDown = () => closing || state.phase === "closed";
+	const reportError = (error) => {
+		try {
+			options.onerror?.(error);
+		} catch {}
+	};
+	const writeErrorResponse = (id, code, message, data) => wire.send({
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code,
+			message,
+			...data !== void 0 && { data }
+		}
+	}).catch((error) => reportError(toError(error)));
+	/**
+	* Entry-handled `subscriptions/listen` for this connection: holds the
+	* active subscriptions, serves inbound listen / cancelled-of-listen
+	* before the pinned instance is consulted, and rewrites the instance's
+	* outbound change notifications onto the active subscriptions. Only
+	* consulted on a modern-pinned connection — on a legacy connection
+	* change notifications pass straight through (the 2025 unsolicited
+	* delivery model is unchanged).
+	*/
+	const listenRouter = new StdioListenRouter(options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS);
+	/** Outbound intercept installed on a modern instance's channel. */
+	const modernOutboundIntercept = (message) => {
+		if (!isJSONRPCNotification(message)) return void 0;
+		const routed = listenRouter.routeOutbound(message);
+		if (routed === "passthrough") return void 0;
+		for (const stamped of routed) wire.send({
+			jsonrpc: "2.0",
+			...stamped
+		}).catch((error) => reportError(toError(error)));
+		return "handled";
+	};
+	/**
+	* Entry-handled inbound listen routing for a modern-pinned connection.
+	* Returns `true` when the message was served at the entry and must NOT
+	* be delivered to the pinned instance.
+	*/
+	const tryServeListen = async (message) => {
+		if (isJSONRPCRequest(message) && message.method === "subscriptions/listen") {
+			const meta = requestMetaOf(message.params);
+			const issue = hasEnvelopeClaim(message.params) ? (meta === void 0 ? [] : validateEnvelopeMeta(meta))[0] : {
+				key: "_meta",
+				problem: "the per-request envelope is required on protocol revision 2026-07-28"
+			};
+			const claimedVersion = envelopeClaimVersion(message.params);
+			let reply;
+			if (issue !== void 0) reply = {
+				jsonrpc: "2.0",
+				id: message.id,
+				error: {
+					code: -32602,
+					message: `Invalid _meta envelope: ${issue.key}: ${issue.problem}`
+				}
+			};
+			else if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) {
+				const error = new UnsupportedProtocolVersionError({
+					supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+					requested: claimedVersion ?? "unknown"
+				});
+				reply = {
+					jsonrpc: "2.0",
+					id: message.id,
+					error: {
+						code: error.code,
+						message: error.message,
+						data: error.data
+					}
+				};
+			} else reply = listenRouter.serve(message);
+			await wire.send("error" in reply ? reply : {
+				jsonrpc: "2.0",
+				method: reply.method,
+				params: reply.params
+			}).catch((error) => reportError(toError(error)));
+			return true;
+		}
+		if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+			const cancelledId = message.params?.requestId;
+			if (cancelledId !== void 0 && listenRouter.cancel(cancelledId)) return true;
+		}
+		return false;
+	};
+	/** Answers a 2025-era request the entry will not serve (the modern-only rejection cells). */
+	const answerLegacyRejection = (request, reason, requestedVersion) => {
+		const rejection = modernOnlyStrictRejection({
+			kind: "legacy",
+			reason,
+			...requestedVersion !== void 0 && { requestedVersion }
+		}, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (rejection === void 0) return Promise.resolve();
+		reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection.cell}): ${rejection.message}`));
+		return writeErrorResponse(request.id, rejection.code, rejection.message, rejection.data);
+	};
+	const onInstanceClosed = (channel) => {
+		if (closing || channel === discarding) return;
+		closeAll();
+	};
+	const connectInstance = async (era, revision) => {
+		const product = await factory({ era });
+		const server = product instanceof McpServer ? product.server : product;
+		if (era === "modern") {
+			setNegotiatedProtocolVersion(server, revision);
+			installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+			listenRouter.setServerCapabilities(server.getCapabilities());
+		}
+		const channel = new StdioConnectionChannel(wire, () => onInstanceClosed(channel), era === "modern" ? modernOutboundIntercept : void 0);
+		await product.connect(channel);
+		return {
+			product,
+			channel
+		};
+	};
+	/** Closes an instance whose factory resolved only after the connection was torn down. */
+	const disposeLateInstance = (instance) => instance.product.close().catch((error) => reportError(toError(error)));
+	const discardProbeInstance = async (instance) => {
+		discarding = instance.channel;
+		try {
+			if (!await instance.channel.whenRequestsAnswered(DISCARD_ANSWER_TIMEOUT_MS)) reportError(/* @__PURE__ */ new Error(`Discarded the probe instance with requests still unanswered after ${DISCARD_ANSWER_TIMEOUT_MS}ms; continuing with the fallback`));
+			await instance.product.close();
+		} catch (error) {
+			reportError(toError(error));
+		} finally {
+			discarding = void 0;
+		}
+	};
+	const processMessage = async (message) => {
+		if (state.phase === "closed") return;
+		if (state.phase === "pinned") {
+			if (state.era === "modern" && isJSONRPCRequest(message) && message.method === "initialize" && !carriesValidModernEnvelopeClaim(message.params)) {
+				await answerLegacyRejection(message, "initialize", message.params !== null && typeof message.params === "object" && typeof message.params.protocolVersion === "string" ? message.params.protocolVersion : void 0);
+				return;
+			}
+			if (state.era === "modern" && await tryServeListen(message)) return;
+			state.instance.channel.deliver(message);
+			return;
+		}
+		if (!isJSONRPCRequest(message) && !isJSONRPCNotification(message)) {
+			reportError(/* @__PURE__ */ new Error("Discarded a JSON-RPC response received before the connection negotiated an era"));
+			return;
+		}
+		const opening = classifyOpeningMessage(message);
+		switch (opening.kind) {
+			case "invalid-envelope": {
+				const detail = `Invalid _meta envelope for protocol revision 2026-07-28: ${opening.issue.key}: ${opening.issue.problem}`;
+				if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InvalidParams, detail, { envelope: opening.issue });
+				else reportError(/* @__PURE__ */ new Error(`Discarded a notification with a malformed envelope: ${detail}`));
+				return;
+			}
+			case "unsupported-revision":
+				if (isJSONRPCRequest(message)) {
+					const error = new UnsupportedProtocolVersionError({
+						supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+						requested: opening.requested
+					});
+					reportError(error);
+					await writeErrorResponse(message.id, error.code, error.message, error.data);
+				} else reportError(/* @__PURE__ */ new Error(`Discarded a notification claiming unsupported protocol revision ${opening.requested}`));
+				return;
+			case "modern":
+				if (isJSONRPCRequest(message) && message.method === "server/discover") {
+					if (state.phase === "probe") {
+						state.instance.channel.deliver(message, { classification: opening.classification });
+						return;
+					}
+					const instance = await connectInstance("modern", opening.revision);
+					if (isTornDown()) {
+						await disposeLateInstance(instance);
+						return;
+					}
+					state = {
+						phase: "probe",
+						instance
+					};
+					instance.channel.deliver(message, { classification: opening.classification });
+					return;
+				}
+				if (state.phase === "probe") {
+					if (isJSONRPCNotification(message)) {
+						state.instance.channel.deliver(message, { classification: opening.classification });
+						return;
+					}
+					state = {
+						phase: "pinned",
+						era: "modern",
+						instance: state.instance
+					};
+				} else {
+					const instance = await connectInstance("modern", opening.revision);
+					if (isTornDown()) {
+						await disposeLateInstance(instance);
+						return;
+					}
+					state = {
+						phase: "pinned",
+						era: "modern",
+						instance
+					};
+				}
+				if (await tryServeListen(message)) return;
+				state.instance.channel.deliver(message, { classification: opening.classification });
+				return;
+			case "legacy": {
+				if (legacyMode === "reject") {
+					if (isJSONRPCRequest(message)) await answerLegacyRejection(message, opening.reason, opening.requestedVersion);
+					return;
+				}
+				if (state.phase === "probe") {
+					await discardProbeInstance(state.instance);
+					if (isTornDown()) return;
+					state = { phase: "opening" };
+				}
+				const instance = await connectInstance("legacy");
+				if (isTornDown()) {
+					await disposeLateInstance(instance);
+					return;
+				}
+				state = {
+					phase: "pinned",
+					era: "legacy",
+					instance
+				};
+				state.instance.channel.deliver(message);
+				return;
+			}
+		}
+	};
+	const queue = [];
+	let pumping = false;
+	const pump = async () => {
+		if (pumping) return;
+		pumping = true;
+		try {
+			while (queue.length > 0) {
+				const message = queue.shift();
+				try {
+					await processMessage(message);
+				} catch (error) {
+					if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InternalError, "Internal server error");
+					reportError(toError(error));
+				}
+			}
+		} finally {
+			pumping = false;
+		}
+	};
+	const closeAll = async () => {
+		if (closing || state.phase === "closed") return;
+		closing = true;
+		const current = state;
+		state = { phase: "closed" };
+		for (const result of listenRouter.teardownAll()) await wire.send(result).catch((error) => reportError(toError(error)));
+		if (current.phase === "probe" || current.phase === "pinned") await current.instance.product.close().catch((error) => reportError(toError(error)));
+		await wire.close().catch((error) => reportError(toError(error)));
+	};
+	wire.onmessage = (message) => {
+		queue.push(message);
+		pump();
+	};
+	wire.onerror = (error) => {
+		reportError(error);
+		if (state.phase === "probe" || state.phase === "pinned") state.instance.channel.onerror?.(error);
+	};
+	wire.onclose = () => {
+		if (closing || state.phase === "closed") return;
+		closing = true;
+		const current = state;
+		state = { phase: "closed" };
+		if (current.phase === "probe" || current.phase === "pinned") current.instance.product.close().catch((error) => reportError(toError(error)));
+	};
+	const started = wire.start().catch((error) => {
+		reportError(toError(error));
+		throw error;
+	});
+	started.catch(() => {});
+	return { close: async () => {
+		await started.catch(() => {});
+		await closeAll();
+	} };
+}
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+
+//#endregion
+export { StdioServerTransport, serveStdio };
 //# sourceMappingURL=stdio.mjs.map