@orkestrel/mcp 0.0.21 → 0.0.23

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

@@ -336,10 +336,14 @@ export declare function createReadableStream<T>(pull: (controller: ReadableStrea
  * inherits it. Each JSON-RPC message the client `send`s is written as one
  * newline-terminated line to the child's `stdin`; each decoded reply line from the
  * child's `stdout` is surfaced on the transport's `message` event for the client's
- * id correlation.
+ * id correlation. That write is bounded: a child that stays alive without ever reading
+ * its `stdin` fills the pipe, and `options.delivery` is how long the unconfirmed write
+ * waits before the `send` rejects. An omitted `delivery` selects {@link
+ * import('./constants.js').DEFAULT_MCP_DELIVERY}; an explicit `0` removes the bound.
  *
  * @param options - `command` (the executable to spawn; REQUIRED), optional `args`,
- *   and optional `env`; see {@link StdioClientTransportOptions}
+ *   optional `env`, and an optional `delivery` bound in milliseconds on an unconfirmed
+ *   `stdin` write; see {@link StdioClientTransportOptions}
  * @returns A working {@link StdioClientTransportInterface} over a child process's stdio,
  *   whose `evidence` carries the supervised child's bounded stderr tail
  *
@@ -498,6 +502,19 @@ export declare function createWebSocketServer(mcp: MCPDispatcherInterface, optio
  */
 export declare function decodeEvent(data: string): JSONRPCMessage | undefined;
 
+/**
+ * The default bound in milliseconds on one unconfirmed write to a stdio client transport's
+ * child `stdin` — the `delivery` a `createStdioClientTransport` caller who supplies none gets.
+ *
+ * @remarks
+ * Ten seconds. The load-bearing property is the ordering, not the magnitude: this bound stays
+ * BELOW {@link import('@orkestrel/mcp').DEFAULT_MCP_REQUEST_TIMEOUT}, so a write the child never
+ * reads fails as an undeliverable message while the request that carried it is still open,
+ * rather than being masked by that request's own deadline expiring first. Override per
+ * transport with `delivery`; an explicit `0` there removes the bound.
+ */
+export declare const DEFAULT_MCP_DELIVERY = 10000;
+
 /**
  * The default interval in milliseconds between SSE keepalive comments on held-open MCP
  * responses.
@@ -1262,9 +1279,10 @@ export declare const SSE_KEEPALIVE_COMMENT = "keepalive";
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated `JSON.stringify`d line
  *   through the supervisor's `send` and AWAITS its answer, so this promise settles only after the
  *   host reports the line handled rather than the moment the write is queued. The supervisor never
- *   rejects — it answers `false` for a channel that was closed, destroyed, or ended, and for a write
- *   that failed — so a `false` answer REJECTS here with the same not-connected error a transport
- *   that was never started raises. A dead peer surfaces at the caller instead of vanishing.
+ *   rejects — it answers `false` for a channel that was closed, destroyed, or ended, for a write
+ *   that failed, or for one that remained unconfirmed through `delivery`. A call made without a
+ *   live child rejects as not connected; a `false` answer from a live child rejects as unable to
+ *   deliver. The supervisor does not disclose which cause produced that answer.
  * - **`close()`** runs the supervisor's bounded termination and teardown, then fires `close` once
  *   (idempotent). That teardown reaches the child's TERMINAL MOMENT, where the supervisor freezes
  *   `evidence`, ends `lines`, and settles `exit` together, so this transport needs no release of
@@ -1307,6 +1325,16 @@ export declare class StdioClientTransport implements StdioClientTransportInterfa
     get duplex(): boolean;
     get evidence(): string | undefined;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message to the live child.
+     *
+     * @param message - The message to write to the child's `stdin`
+     * @returns Resolves when the supervisor confirms the write
+     * @throws Thrown with `stdio transport is not connected` when no live child is available before
+     *   the write
+     * @throws Thrown with `stdio transport could not deliver the message` when a live child's write
+     *   resolves `false`
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1391,11 +1419,34 @@ export declare interface StdioClientTransportInterface extends MCPClientTranspor
  *   OMITTED the child inherits the full `process.env`, when PROVIDED each named key overrides
  *   the inherited value while every unlisted key is still inherited. This transport cannot
  *   REPLACE the inherited environment entirely — the supervisor always merges over the parent.
+ * - `delivery` — the bound in milliseconds on one unconfirmed write to the child's `stdin`;
+ *   an explicit `0` opts out. Defaults to {@link import('./constants.js').DEFAULT_MCP_DELIVERY}.
  */
 export declare interface StdioClientTransportOptions {
     readonly command: string;
     readonly args?: readonly string[];
     readonly env?: Readonly<Record<string, string>>;
+    /**
+     * Bounds the wait on one unconfirmed `send` write to the child's `stdin`, in milliseconds.
+     *
+     * @remarks
+     * A full pipe is the case this bounds: a live child that never reads its `stdin` leaves the
+     * kernel unable to confirm the write, and the supervisor holds that write open. When the
+     * window elapses the supervisor answers that write `false`, which this transport surfaces as
+     * a rejection, so the caller learns the message did not land instead of waiting on a peer
+     * that will never read it. Default: {@link import('./constants.js').DEFAULT_MCP_DELIVERY}.
+     *
+     * An explicit `0` opts out: the bound is off, and an unconfirmed write stays pending until
+     * the channel faults or teardown settles it. Omission does NOT opt out here, which is where
+     * this option diverges from the supervisor's own `delivery` on {@link
+     * import('@orkestrel/process').ProcessOptions} — omitted THERE disables the bound, omitted
+     * HERE selects the default.
+     *
+     * An out-of-range value surfaces at `start()` rather than at construction. This transport
+     * forwards the value verbatim and adds no validator of its own, so the supervisor's own timer
+     * range is what rejects it, at the moment it spawns the child.
+     */
+    readonly delivery?: number;
 }
 
 /**
@@ -1433,8 +1484,10 @@ export declare interface StdioServerOptions {
  *   emits `error` (never throws). `input`'s `close` bridges to this
  *   transport's `close`.
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated
- *   `JSON.stringify`d line to `output`.
- * - **`close()`** removes this transport's input subscriptions and fires its `close`
+ *   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+ *   callback is the backpressure boundary and its error rejects the send.
+ * - **`close()`** removes this transport's input and output subscriptions, rejects every
+ *   pending send, and fires its `close`
  *   event (idempotent). It pauses the input only when the caller was not already reading
  *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
  *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1457,6 +1510,19 @@ export declare class StdioServerTransport implements MCPClientTransportInterface
     get session(): string | undefined;
     get duplex(): boolean;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+     *
+     * @remarks
+     * The writable completion callback is the backpressure boundary. This method awaits that
+     * callback rather than adding a `drain` listener. Closing the transport rejects every send
+     * whose callback has not settled.
+     *
+     * @param message - The message to serialize and write
+     * @returns Resolves when the output confirms the write
+     * @throws Thrown with `stdio transport is not connected` after the transport closes
+     * @throws Thrown with the output callback error or synchronous write failure
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1633,4 +1699,22 @@ export declare class WebSocketServerTransport implements MCPClientTransportInter
     close(): Promise<void>;
 }
 
+/**
+ * Writes one line to a Node writable stream and waits for its completion callback.
+ *
+ * @remarks
+ * The completion callback is the writable channel's backpressure boundary. A callback error and
+ * a synchronous `write` throw reject the returned promise with the original value.
+ *
+ * @param output - The writable stream that receives the line
+ * @param line - The complete line to write
+ * @returns Resolves when the stream confirms the write; rejects when the write fails
+ *
+ * @example
+ * ```ts
+ * await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+ * ```
+ */
+export declare function writeLine(output: NodeJS.WritableStream, line: string): Promise<void>;
+
 export { }

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

@@ -336,10 +336,14 @@ export declare function createReadableStream<T>(pull: (controller: ReadableStrea
  * inherits it. Each JSON-RPC message the client `send`s is written as one
  * newline-terminated line to the child's `stdin`; each decoded reply line from the
  * child's `stdout` is surfaced on the transport's `message` event for the client's
- * id correlation.
+ * id correlation. That write is bounded: a child that stays alive without ever reading
+ * its `stdin` fills the pipe, and `options.delivery` is how long the unconfirmed write
+ * waits before the `send` rejects. An omitted `delivery` selects {@link
+ * import('./constants.js').DEFAULT_MCP_DELIVERY}; an explicit `0` removes the bound.
  *
  * @param options - `command` (the executable to spawn; REQUIRED), optional `args`,
- *   and optional `env`; see {@link StdioClientTransportOptions}
+ *   optional `env`, and an optional `delivery` bound in milliseconds on an unconfirmed
+ *   `stdin` write; see {@link StdioClientTransportOptions}
  * @returns A working {@link StdioClientTransportInterface} over a child process's stdio,
  *   whose `evidence` carries the supervised child's bounded stderr tail
  *
@@ -498,6 +502,19 @@ export declare function createWebSocketServer(mcp: MCPDispatcherInterface, optio
  */
 export declare function decodeEvent(data: string): JSONRPCMessage | undefined;
 
+/**
+ * The default bound in milliseconds on one unconfirmed write to a stdio client transport's
+ * child `stdin` — the `delivery` a `createStdioClientTransport` caller who supplies none gets.
+ *
+ * @remarks
+ * Ten seconds. The load-bearing property is the ordering, not the magnitude: this bound stays
+ * BELOW {@link import('@orkestrel/mcp').DEFAULT_MCP_REQUEST_TIMEOUT}, so a write the child never
+ * reads fails as an undeliverable message while the request that carried it is still open,
+ * rather than being masked by that request's own deadline expiring first. Override per
+ * transport with `delivery`; an explicit `0` there removes the bound.
+ */
+export declare const DEFAULT_MCP_DELIVERY = 10000;
+
 /**
  * The default interval in milliseconds between SSE keepalive comments on held-open MCP
  * responses.
@@ -1262,9 +1279,10 @@ export declare const SSE_KEEPALIVE_COMMENT = "keepalive";
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated `JSON.stringify`d line
  *   through the supervisor's `send` and AWAITS its answer, so this promise settles only after the
  *   host reports the line handled rather than the moment the write is queued. The supervisor never
- *   rejects — it answers `false` for a channel that was closed, destroyed, or ended, and for a write
- *   that failed — so a `false` answer REJECTS here with the same not-connected error a transport
- *   that was never started raises. A dead peer surfaces at the caller instead of vanishing.
+ *   rejects — it answers `false` for a channel that was closed, destroyed, or ended, for a write
+ *   that failed, or for one that remained unconfirmed through `delivery`. A call made without a
+ *   live child rejects as not connected; a `false` answer from a live child rejects as unable to
+ *   deliver. The supervisor does not disclose which cause produced that answer.
  * - **`close()`** runs the supervisor's bounded termination and teardown, then fires `close` once
  *   (idempotent). That teardown reaches the child's TERMINAL MOMENT, where the supervisor freezes
  *   `evidence`, ends `lines`, and settles `exit` together, so this transport needs no release of
@@ -1307,6 +1325,16 @@ export declare class StdioClientTransport implements StdioClientTransportInterfa
     get duplex(): boolean;
     get evidence(): string | undefined;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message to the live child.
+     *
+     * @param message - The message to write to the child's `stdin`
+     * @returns Resolves when the supervisor confirms the write
+     * @throws Thrown with `stdio transport is not connected` when no live child is available before
+     *   the write
+     * @throws Thrown with `stdio transport could not deliver the message` when a live child's write
+     *   resolves `false`
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1391,11 +1419,34 @@ export declare interface StdioClientTransportInterface extends MCPClientTranspor
  *   OMITTED the child inherits the full `process.env`, when PROVIDED each named key overrides
  *   the inherited value while every unlisted key is still inherited. This transport cannot
  *   REPLACE the inherited environment entirely — the supervisor always merges over the parent.
+ * - `delivery` — the bound in milliseconds on one unconfirmed write to the child's `stdin`;
+ *   an explicit `0` opts out. Defaults to {@link import('./constants.js').DEFAULT_MCP_DELIVERY}.
  */
 export declare interface StdioClientTransportOptions {
     readonly command: string;
     readonly args?: readonly string[];
     readonly env?: Readonly<Record<string, string>>;
+    /**
+     * Bounds the wait on one unconfirmed `send` write to the child's `stdin`, in milliseconds.
+     *
+     * @remarks
+     * A full pipe is the case this bounds: a live child that never reads its `stdin` leaves the
+     * kernel unable to confirm the write, and the supervisor holds that write open. When the
+     * window elapses the supervisor answers that write `false`, which this transport surfaces as
+     * a rejection, so the caller learns the message did not land instead of waiting on a peer
+     * that will never read it. Default: {@link import('./constants.js').DEFAULT_MCP_DELIVERY}.
+     *
+     * An explicit `0` opts out: the bound is off, and an unconfirmed write stays pending until
+     * the channel faults or teardown settles it. Omission does NOT opt out here, which is where
+     * this option diverges from the supervisor's own `delivery` on {@link
+     * import('@orkestrel/process').ProcessOptions} — omitted THERE disables the bound, omitted
+     * HERE selects the default.
+     *
+     * An out-of-range value surfaces at `start()` rather than at construction. This transport
+     * forwards the value verbatim and adds no validator of its own, so the supervisor's own timer
+     * range is what rejects it, at the moment it spawns the child.
+     */
+    readonly delivery?: number;
 }
 
 /**
@@ -1433,8 +1484,10 @@ export declare interface StdioServerOptions {
  *   emits `error` (never throws). `input`'s `close` bridges to this
  *   transport's `close`.
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated
- *   `JSON.stringify`d line to `output`.
- * - **`close()`** removes this transport's input subscriptions and fires its `close`
+ *   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+ *   callback is the backpressure boundary and its error rejects the send.
+ * - **`close()`** removes this transport's input and output subscriptions, rejects every
+ *   pending send, and fires its `close`
  *   event (idempotent). It pauses the input only when the caller was not already reading
  *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
  *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1457,6 +1510,19 @@ export declare class StdioServerTransport implements MCPClientTransportInterface
     get session(): string | undefined;
     get duplex(): boolean;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+     *
+     * @remarks
+     * The writable completion callback is the backpressure boundary. This method awaits that
+     * callback rather than adding a `drain` listener. Closing the transport rejects every send
+     * whose callback has not settled.
+     *
+     * @param message - The message to serialize and write
+     * @returns Resolves when the output confirms the write
+     * @throws Thrown with `stdio transport is not connected` after the transport closes
+     * @throws Thrown with the output callback error or synchronous write failure
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1633,4 +1699,22 @@ export declare class WebSocketServerTransport implements MCPClientTransportInter
     close(): Promise<void>;
 }
 
+/**
+ * Writes one line to a Node writable stream and waits for its completion callback.
+ *
+ * @remarks
+ * The completion callback is the writable channel's backpressure boundary. A callback error and
+ * a synchronous `write` throw reject the returned promise with the original value.
+ *
+ * @param output - The writable stream that receives the line
+ * @param line - The complete line to write
+ * @returns Resolves when the stream confirms the write; rejects when the write fails
+ *
+ * @example
+ * ```ts
+ * await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+ * ```
+ */
+export declare function writeLine(output: NodeJS.WritableStream, line: string): Promise<void>;
+
 export { }

package/dist/src/server/index.js

@@ -84,6 +84,18 @@ var DEFAULT_MCP_SESSION_CAPACITY = 1024;
 * this bounds the replay log paired with it.
 */
 var DEFAULT_MCP_SESSION_TTL = 3e5;
+/**
+* The default bound in milliseconds on one unconfirmed write to a stdio client transport's
+* child `stdin` — the `delivery` a `createStdioClientTransport` caller who supplies none gets.
+*
+* @remarks
+* Ten seconds. The load-bearing property is the ordering, not the magnitude: this bound stays
+* BELOW {@link import('@orkestrel/mcp').DEFAULT_MCP_REQUEST_TIMEOUT}, so a write the child never
+* reads fails as an undeliverable message while the request that carried it is still open,
+* rather than being masked by that request's own deadline expiring first. Override per
+* transport with `delivery`; an explicit `0` there removes the bound.
+*/
+var DEFAULT_MCP_DELIVERY = 1e4;
 //#endregion
 //#region src/server/helpers.ts
 /**
@@ -352,6 +364,34 @@ function extractLines(buffer, chunk) {
 	};
 }
 /**
+* Writes one line to a Node writable stream and waits for its completion callback.
+*
+* @remarks
+* The completion callback is the writable channel's backpressure boundary. A callback error and
+* a synchronous `write` throw reject the returned promise with the original value.
+*
+* @param output - The writable stream that receives the line
+* @param line - The complete line to write
+* @returns Resolves when the stream confirms the write; rejects when the write fails
+*
+* @example
+* ```ts
+* await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+* ```
+*/
+function writeLine(output, line) {
+	return new Promise((resolve, reject) => {
+		try {
+			output.write(line, (error) => {
+				if (error === void 0 || error === null) resolve();
+				else reject(error);
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+/**
 * Decodes and delivers each complete newline-framed line onto a {@link
 * MCPClientTransportEventMap} emitter — the shared per-chunk dispatch step both stdio
 * transports run their framed lines through: the server transport frames with {@link
@@ -1380,9 +1420,10 @@ var WebSocketClientTransport = class {
 * - **Outbound (`send`).** `send(message)` writes one newline-terminated `JSON.stringify`d line
 *   through the supervisor's `send` and AWAITS its answer, so this promise settles only after the
 *   host reports the line handled rather than the moment the write is queued. The supervisor never
-*   rejects — it answers `false` for a channel that was closed, destroyed, or ended, and for a write
-*   that failed — so a `false` answer REJECTS here with the same not-connected error a transport
-*   that was never started raises. A dead peer surfaces at the caller instead of vanishing.
+*   rejects — it answers `false` for a channel that was closed, destroyed, or ended, for a write
+*   that failed, or for one that remained unconfirmed through `delivery`. A call made without a
+*   live child rejects as not connected; a `false` answer from a live child rejects as unable to
+*   deliver. The supervisor does not disclose which cause produced that answer.
 * - **`close()`** runs the supervisor's bounded termination and teardown, then fires `close` once
 *   (idempotent). That teardown reaches the child's TERMINAL MOMENT, where the supervisor freezes
 *   `evidence`, ends `lines`, and settles `exit` together, so this transport needs no release of
@@ -1422,6 +1463,7 @@ var StdioClientTransport = class {
 	#command;
 	#args;
 	#env;
+	#delivery;
 	#process = void 0;
 	#closing = void 0;
 	#closed = false;
@@ -1430,6 +1472,7 @@ var StdioClientTransport = class {
 		this.#command = options.command;
 		this.#args = options.args ?? [];
 		this.#env = options.env;
+		this.#delivery = options.delivery ?? 1e4;
 	}
 	get emitter() {
 		return this.#emitter;
@@ -1461,6 +1504,7 @@ var StdioClientTransport = class {
 			},
 			workspace: process.cwd(),
 			grace: PROCESS_GRACE,
+			delivery: this.#delivery,
 			writable: true
 		});
 		this.#process = child;
@@ -1468,9 +1512,20 @@ var StdioClientTransport = class {
 		child.exit.then((exit) => this.#onExit(child, exit));
 		this.#pump(child);
 	}
+	/**
+	* Sends one newline-delimited JSON-RPC message to the live child.
+	*
+	* @param message - The message to write to the child's `stdin`
+	* @returns Resolves when the supervisor confirms the write
+	* @throws Thrown with `stdio transport is not connected` when no live child is available before
+	*   the write
+	* @throws Thrown with `stdio transport could not deliver the message` when a live child's write
+	*   resolves `false`
+	*/
 	async send(message) {
 		const child = this.#closed ? void 0 : this.#process;
-		if (!(child === void 0 ? false : await child.send(JSON.stringify(message)))) throw new Error("stdio transport is not connected");
+		if (child === void 0) throw new Error("stdio transport is not connected");
+		if (!await child.send(JSON.stringify(message))) throw new Error("stdio transport could not deliver the message");
 	}
 	async close() {
 		if (this.#closed && this.#closing === void 0) return;
@@ -1531,8 +1586,10 @@ var StdioClientTransport = class {
 *   emits `error` (never throws). `input`'s `close` bridges to this
 *   transport's `close`.
 * - **Outbound (`send`).** `send(message)` writes one newline-terminated
-*   `JSON.stringify`d line to `output`.
-* - **`close()`** removes this transport's input subscriptions and fires its `close`
+*   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+*   callback is the backpressure boundary and its error rejects the send.
+* - **`close()`** removes this transport's input and output subscriptions, rejects every
+*   pending send, and fires its `close`
 *   event (idempotent). It pauses the input only when the caller was not already reading
 *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
 *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1555,6 +1612,7 @@ var StdioServerTransport = class {
 	#data = (chunk) => this.#receive(chunk.toString());
 	#ending = () => this.#onClose();
 	#failure = (error) => this.#emitter.emit("error", error);
+	#pending = /* @__PURE__ */ new Set();
 	#buffer = "";
 	#started = false;
 	#closed = false;
@@ -1578,9 +1636,30 @@ var StdioServerTransport = class {
 		this.#input.on("data", this.#data);
 		this.#input.on("close", this.#ending);
 		this.#input.on("error", this.#failure);
+		this.#output.on("error", this.#failure);
 	}
+	/**
+	* Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+	*
+	* @remarks
+	* The writable completion callback is the backpressure boundary. This method awaits that
+	* callback rather than adding a `drain` listener. Closing the transport rejects every send
+	* whose callback has not settled.
+	*
+	* @param message - The message to serialize and write
+	* @returns Resolves when the output confirms the write
+	* @throws Thrown with `stdio transport is not connected` after the transport closes
+	* @throws Thrown with the output callback error or synchronous write failure
+	*/
 	async send(message) {
-		this.#output.write(`${JSON.stringify(message)}\n`);
+		if (this.#closed) throw new Error("stdio transport is not connected");
+		const pending = Promise.withResolvers();
+		this.#pending.add(pending);
+		try {
+			await Promise.race([writeLine(this.#output, `${JSON.stringify(message)}\n`), pending.promise]);
+		} finally {
+			this.#pending.delete(pending);
+		}
 	}
 	async close() {
 		if (this.#closed) return;
@@ -1603,6 +1682,9 @@ var StdioServerTransport = class {
 		this.#input.removeListener("data", this.#data);
 		this.#input.removeListener("close", this.#ending);
 		this.#input.removeListener("error", this.#failure);
+		this.#output.removeListener("error", this.#failure);
+		for (const pending of this.#pending) pending.reject(/* @__PURE__ */ new Error("stdio transport is not connected"));
+		this.#pending.clear();
 		if (!this.#flowing && this.#input.listenerCount("data") === 0) this.#input.pause();
 	}
 };
@@ -1864,10 +1946,14 @@ function createWebSocketClientTransport(options) {
 * inherits it. Each JSON-RPC message the client `send`s is written as one
 * newline-terminated line to the child's `stdin`; each decoded reply line from the
 * child's `stdout` is surfaced on the transport's `message` event for the client's
-* id correlation.
+* id correlation. That write is bounded: a child that stays alive without ever reading
+* its `stdin` fills the pipe, and `options.delivery` is how long the unconfirmed write
+* waits before the `send` rejects. An omitted `delivery` selects {@link
+* import('./constants.js').DEFAULT_MCP_DELIVERY}; an explicit `0` removes the bound.
 *
 * @param options - `command` (the executable to spawn; REQUIRED), optional `args`,
-*   and optional `env`; see {@link StdioClientTransportOptions}
+*   optional `env`, and an optional `delivery` bound in milliseconds on an unconfirmed
+*   `stdin` write; see {@link StdioClientTransportOptions}
 * @returns A working {@link StdioClientTransportInterface} over a child process's stdio,
 *   whose `evidence` carries the supervised child's bounded stderr tail
 *
@@ -2106,6 +2192,6 @@ function createMCPSession(options) {
 	};
 }
 //#endregion
-export { DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, HTTPDisconnect, MCPSession, MCP_METHOD_HEADER, MCP_NAME_HEADER, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, bridgeMessageTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createReadableStream, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, inferHeaderIssue, inferLegacyVersion, inferStatus, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath };
+export { DEFAULT_MCP_DELIVERY, DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, HTTPDisconnect, MCPSession, MCP_METHOD_HEADER, MCP_NAME_HEADER, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, bridgeMessageTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createReadableStream, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, inferHeaderIssue, inferLegacyVersion, inferStatus, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath, writeLine };
 
 //# sourceMappingURL=index.js.map