@orkestrel/mcp 0.0.34 → 0.0.36

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

@@ -181,6 +181,8 @@ export declare function createMCPContinuation(secret: TokenSecret): MCPContinuat
  * handler through `MCPDispatchOptions.signal`. After every transport validation and immediately
  * before dispatch, the optional synchronous `caller` extractor reads front-middleware state; a
  * defined value is added to `MCPDispatchOptions`, while `undefined` is omitted.
+ * For legacy `initialize`, the dispatch response is recorded as `initialization` before
+ * JSON or SSE framing only when consumer state is an object with `'session' in context.state`.
  *
  * @typeParam TState - The consumer's opaque per-request route state type
  * @param mcp - The transport-agnostic MCP dispatcher to dispatch through
@@ -286,8 +288,12 @@ export declare function createMCPRoutes<TState = unknown>(mcp: MCPDispatcherInte
  *   live-session request. It then
  *   forwards a fresh `Request` carrying the buffered `text` (`next(forwarded)`) — never the
  *   already-consumed original — so the route re-reads the same body, and stamps the response
- *   with {@link MCP_SESSION_HEADER}. The entry's `touched` instant is read after that
- *   downstream response, because it means the last access: a request slower than `ttl` would
+ *   with {@link MCP_SESSION_HEADER}. A candidate entry is stored and advertised only when
+ *   `context.state.initialization` carries a result. An `initialize` that would mint a session
+ *   stores none and advertises none when refused; a live session's header is returned unchanged.
+ *   The POST handler records that dispatch response before JSON or SSE framing.
+ *   The entry's `touched` instant is read after the downstream response, because it
+ *   means the last access: a request slower than `ttl` would
  *   otherwise store a session that is already expired, and the write-back RE-ASKS the store, so
  *   a `DELETE` arriving while the request was suspended is not undone.
  * - **`GET {path}`.** Resolves the session the same way (no mint — only `initialize` mints);
@@ -548,7 +554,7 @@ export declare const DEFAULT_MCP_SESSION_TTL = 300000;
  * Decodes and delivers each complete newline-framed line onto a {@link
  * MCPMessageTransportEventMap} emitter — the shared per-chunk dispatch step both stdio
  * transports run their framed lines through: the server transport frames with {@link
- * extractLines}, the client transport takes its lines from the process supervisor.
+ * extractLines}, the client transport frames the supervisor's stdout with Node's `readline`.
  *
  * @remarks
  * A blank line is skipped (a stray trailing newline). Every other line runs through the
@@ -855,6 +861,16 @@ export declare interface LineExtraction {
     readonly remainder: string;
 }
 
+/**
+ * Sets the bound in milliseconds for a stdio server to exit after the client ends its input.
+ *
+ * @remarks
+ * Gives EOF cleanup half the process supervisor's 5,000 ms signal grace before escalation gets
+ * its existing full window. This bounds the MCP lifecycle's reasonable-time wait without spending
+ * another full signal grace before termination. Pending input flushes share this bound.
+ */
+export declare const MCP_STDIO_GRACE: number;
+
 /**
  * Extracts consumer-asserted caller context synchronously from an HTTP request after the
  * transport has validated it for dispatch.
@@ -1130,13 +1146,16 @@ export declare interface MCPSessionOptions {
  * a server-initiated message onto the session's resumable stream.
  *
  * @remarks
- * `session` is set on `initialize` (the minted session) and on every validated
+ * `session` is set on `initialize` (the candidate or resolved live session) and on every validated
  * non-`initialize` `POST` (the resolved one); absent when the request never
  * reached a resolved session (the middleware short-circuits those as a `404`
- * before calling `next`).
+ * before calling `next`). A refused candidate remains in request state but is never
+ * stored or advertised. A live session's response header is returned unchanged.
  */
 export declare interface MCPSessionState {
     readonly session?: MCPSessionInterface;
+    /** Holds the initialization dispatch response before HTTP framing, used to admit a session. */
+    readonly initialization?: JSONRPCResponse;
 }
 
 /**
@@ -1240,32 +1259,37 @@ export declare const SSE_KEEPALIVE_COMMENT = "keepalive";
  *
  * @remarks
  * - **Composes `@orkestrel/process`.** `start()` builds one supervised
- *   {@link import('@orkestrel/process/server').Process} with `writable: true`, so the child's
+ *   {@link import('@orkestrel/process/server').Supervisor} with `writable: true`, so the child's
  *   `stdin`/`stdout` are the JSON-RPC channel and its `stderr` is retained as bounded evidence
- *   rather than parsed as protocol. The supervisor owns spawn, framing, and termination.
- * - **Inbound (`message`).** Standard output is drained eagerly through the supervisor's
- *   `readline`-framed `lines` iterable, so a multi-byte UTF-8 sequence split across two reads is
+ *   rather than parsed as protocol. The supervisor owns spawn and termination.
+ * - **Inbound (`message`).** Standard output is drained eagerly through Node's `readline`,
+ *   so a multi-byte UTF-8 sequence split across two reads is
  *   decoded whole and a final line written without a trailing newline still arrives. Each framed
  *   line is decoded and delivered through the shared {@link dispatchLines} helper — a well-formed
  *   {@link JSONRPCMessage} emits `message`, a malformed line emits `error` (never throws).
  * - **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
+ *   through the supervisor's `deliver` 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, 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
- *   its own to get its line pump back: the stream ends under the pump rather than throwing at it.
- *   A line the supervisor had already framed behind the one being delivered is dropped rather than
+ * - **`close()`** ends the child's input and waits up to {@link MCP_STDIO_GRACE} for native exit,
+ *   including any pending input flush. Only after that wait does the supervisor terminate a child
+ *   that remains alive. Teardown freezes `evidence`, closes the reader, and settles `exit`, then
+ *   fires `close` once (idempotent).
+ *   A child that exits on input end within the grace receives no termination signal, so it must
+ *   end its own child processes on input end; only escalation reaches its process tree.
+ *   If an `MCPClient` request `timeout` is shorter than the grace and the close outlasts that
+ *   timeout, `disconnect()` rejects with `MCP transport close timed out after <timeout>ms`.
+ *   The close keeps running, and a later caller joins it while it remains pending.
+ *   A line already framed behind the one being delivered is dropped rather than
  *   emitted onto a transport whose teardown has begun. A `close()` issued while that teardown runs
  *   joins it rather than opening a second one, so it resolves only after `close` has fired, and a
  *   `start()` issued while it runs waits behind the same barrier, so lifetimes never overlap. A
  *   descendant can retain an inherited stdout pipe after the child exits; the supervisor's `drain`
- *   bound cuts that wait off, so this transport's `close()` settles within that bound rather than
- *   on the descendant. The termination itself belongs to the host: a POSIX host signals the
+ *   bound cuts that wait off independently of the input grace. Escalation belongs to the host:
+ *   a POSIX host signals the
  *   child's own process group `SIGTERM`, waits the grace window, then `SIGKILL`s through the same
  *   route, so the kill reaches grandchildren rather than orphaning them, while Windows ends the
  *   tree with `taskkill /F /T`, which nothing in the child can intercept.
@@ -1324,6 +1348,14 @@ export declare class StdioClientTransport implements StdioClientTransportInterfa
  * of them answers `undefined` to forever is a stdio detail rather than a shared contract. A
  * consumer that widens this value back to {@link MCPMessageTransportInterface}, including by
  * reading `client.transport`, loses the reader and must keep the original reference.
+ * Closing ends the child's input, waits up to {@link import('./constants.js').MCP_STDIO_GRACE}
+ * for native exit, and then uses the supervisor's bounded termination if the child remains alive.
+ * The input flush shares that bound; the supervisor's stream-drain bound follows native exit.
+ * A child that exits on input end within the grace receives no termination signal and must end
+ * its own child processes on input end; only escalation reaches its process tree. If an
+ * `MCPClient` request `timeout` is shorter than the grace and the close outlasts that timeout,
+ * `disconnect()` rejects with `MCP transport close timed out after <timeout>ms`. The close keeps
+ * running, and a later caller joins it while it remains pending.
  */
 export declare interface StdioClientTransportInterface extends MCPMessageTransportInterface {
     /**
@@ -1357,7 +1389,8 @@ export declare interface StdioClientTransportInterface extends MCPMessageTranspo
      *   would have read.
      * - **What the close path carries.** The frozen value is what the supervisor had received by
      *   that terminal moment, not the child's complete output.
-     *   Windows ends the tree with `taskkill /F /T`, which nothing in the child can intercept: a
+     *   After the input grace expires, Windows ends the tree with `taskkill /F /T`, which nothing
+     *   in the child can intercept: a
      *   `SIGTERM` handler never runs there, so the bytes it would have written never exist. A
      *   child that ends on its own closes its stderr first, and that tail is complete.
      *   Where that moment arrived at the supervisor's `drain` bound rather than at the child's

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

@@ -181,6 +181,8 @@ export declare function createMCPContinuation(secret: TokenSecret): MCPContinuat
  * handler through `MCPDispatchOptions.signal`. After every transport validation and immediately
  * before dispatch, the optional synchronous `caller` extractor reads front-middleware state; a
  * defined value is added to `MCPDispatchOptions`, while `undefined` is omitted.
+ * For legacy `initialize`, the dispatch response is recorded as `initialization` before
+ * JSON or SSE framing only when consumer state is an object with `'session' in context.state`.
  *
  * @typeParam TState - The consumer's opaque per-request route state type
  * @param mcp - The transport-agnostic MCP dispatcher to dispatch through
@@ -286,8 +288,12 @@ export declare function createMCPRoutes<TState = unknown>(mcp: MCPDispatcherInte
  *   live-session request. It then
  *   forwards a fresh `Request` carrying the buffered `text` (`next(forwarded)`) — never the
  *   already-consumed original — so the route re-reads the same body, and stamps the response
- *   with {@link MCP_SESSION_HEADER}. The entry's `touched` instant is read after that
- *   downstream response, because it means the last access: a request slower than `ttl` would
+ *   with {@link MCP_SESSION_HEADER}. A candidate entry is stored and advertised only when
+ *   `context.state.initialization` carries a result. An `initialize` that would mint a session
+ *   stores none and advertises none when refused; a live session's header is returned unchanged.
+ *   The POST handler records that dispatch response before JSON or SSE framing.
+ *   The entry's `touched` instant is read after the downstream response, because it
+ *   means the last access: a request slower than `ttl` would
  *   otherwise store a session that is already expired, and the write-back RE-ASKS the store, so
  *   a `DELETE` arriving while the request was suspended is not undone.
  * - **`GET {path}`.** Resolves the session the same way (no mint — only `initialize` mints);
@@ -548,7 +554,7 @@ export declare const DEFAULT_MCP_SESSION_TTL = 300000;
  * Decodes and delivers each complete newline-framed line onto a {@link
  * MCPMessageTransportEventMap} emitter — the shared per-chunk dispatch step both stdio
  * transports run their framed lines through: the server transport frames with {@link
- * extractLines}, the client transport takes its lines from the process supervisor.
+ * extractLines}, the client transport frames the supervisor's stdout with Node's `readline`.
  *
  * @remarks
  * A blank line is skipped (a stray trailing newline). Every other line runs through the
@@ -855,6 +861,16 @@ export declare interface LineExtraction {
     readonly remainder: string;
 }
 
+/**
+ * Sets the bound in milliseconds for a stdio server to exit after the client ends its input.
+ *
+ * @remarks
+ * Gives EOF cleanup half the process supervisor's 5,000 ms signal grace before escalation gets
+ * its existing full window. This bounds the MCP lifecycle's reasonable-time wait without spending
+ * another full signal grace before termination. Pending input flushes share this bound.
+ */
+export declare const MCP_STDIO_GRACE: number;
+
 /**
  * Extracts consumer-asserted caller context synchronously from an HTTP request after the
  * transport has validated it for dispatch.
@@ -1130,13 +1146,16 @@ export declare interface MCPSessionOptions {
  * a server-initiated message onto the session's resumable stream.
  *
  * @remarks
- * `session` is set on `initialize` (the minted session) and on every validated
+ * `session` is set on `initialize` (the candidate or resolved live session) and on every validated
  * non-`initialize` `POST` (the resolved one); absent when the request never
  * reached a resolved session (the middleware short-circuits those as a `404`
- * before calling `next`).
+ * before calling `next`). A refused candidate remains in request state but is never
+ * stored or advertised. A live session's response header is returned unchanged.
  */
 export declare interface MCPSessionState {
     readonly session?: MCPSessionInterface;
+    /** Holds the initialization dispatch response before HTTP framing, used to admit a session. */
+    readonly initialization?: JSONRPCResponse;
 }
 
 /**
@@ -1240,32 +1259,37 @@ export declare const SSE_KEEPALIVE_COMMENT = "keepalive";
  *
  * @remarks
  * - **Composes `@orkestrel/process`.** `start()` builds one supervised
- *   {@link import('@orkestrel/process/server').Process} with `writable: true`, so the child's
+ *   {@link import('@orkestrel/process/server').Supervisor} with `writable: true`, so the child's
  *   `stdin`/`stdout` are the JSON-RPC channel and its `stderr` is retained as bounded evidence
- *   rather than parsed as protocol. The supervisor owns spawn, framing, and termination.
- * - **Inbound (`message`).** Standard output is drained eagerly through the supervisor's
- *   `readline`-framed `lines` iterable, so a multi-byte UTF-8 sequence split across two reads is
+ *   rather than parsed as protocol. The supervisor owns spawn and termination.
+ * - **Inbound (`message`).** Standard output is drained eagerly through Node's `readline`,
+ *   so a multi-byte UTF-8 sequence split across two reads is
  *   decoded whole and a final line written without a trailing newline still arrives. Each framed
  *   line is decoded and delivered through the shared {@link dispatchLines} helper — a well-formed
  *   {@link JSONRPCMessage} emits `message`, a malformed line emits `error` (never throws).
  * - **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
+ *   through the supervisor's `deliver` 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, 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
- *   its own to get its line pump back: the stream ends under the pump rather than throwing at it.
- *   A line the supervisor had already framed behind the one being delivered is dropped rather than
+ * - **`close()`** ends the child's input and waits up to {@link MCP_STDIO_GRACE} for native exit,
+ *   including any pending input flush. Only after that wait does the supervisor terminate a child
+ *   that remains alive. Teardown freezes `evidence`, closes the reader, and settles `exit`, then
+ *   fires `close` once (idempotent).
+ *   A child that exits on input end within the grace receives no termination signal, so it must
+ *   end its own child processes on input end; only escalation reaches its process tree.
+ *   If an `MCPClient` request `timeout` is shorter than the grace and the close outlasts that
+ *   timeout, `disconnect()` rejects with `MCP transport close timed out after <timeout>ms`.
+ *   The close keeps running, and a later caller joins it while it remains pending.
+ *   A line already framed behind the one being delivered is dropped rather than
  *   emitted onto a transport whose teardown has begun. A `close()` issued while that teardown runs
  *   joins it rather than opening a second one, so it resolves only after `close` has fired, and a
  *   `start()` issued while it runs waits behind the same barrier, so lifetimes never overlap. A
  *   descendant can retain an inherited stdout pipe after the child exits; the supervisor's `drain`
- *   bound cuts that wait off, so this transport's `close()` settles within that bound rather than
- *   on the descendant. The termination itself belongs to the host: a POSIX host signals the
+ *   bound cuts that wait off independently of the input grace. Escalation belongs to the host:
+ *   a POSIX host signals the
  *   child's own process group `SIGTERM`, waits the grace window, then `SIGKILL`s through the same
  *   route, so the kill reaches grandchildren rather than orphaning them, while Windows ends the
  *   tree with `taskkill /F /T`, which nothing in the child can intercept.
@@ -1324,6 +1348,14 @@ export declare class StdioClientTransport implements StdioClientTransportInterfa
  * of them answers `undefined` to forever is a stdio detail rather than a shared contract. A
  * consumer that widens this value back to {@link MCPMessageTransportInterface}, including by
  * reading `client.transport`, loses the reader and must keep the original reference.
+ * Closing ends the child's input, waits up to {@link import('./constants.js').MCP_STDIO_GRACE}
+ * for native exit, and then uses the supervisor's bounded termination if the child remains alive.
+ * The input flush shares that bound; the supervisor's stream-drain bound follows native exit.
+ * A child that exits on input end within the grace receives no termination signal and must end
+ * its own child processes on input end; only escalation reaches its process tree. If an
+ * `MCPClient` request `timeout` is shorter than the grace and the close outlasts that timeout,
+ * `disconnect()` rejects with `MCP transport close timed out after <timeout>ms`. The close keeps
+ * running, and a later caller joins it while it remains pending.
  */
 export declare interface StdioClientTransportInterface extends MCPMessageTransportInterface {
     /**
@@ -1357,7 +1389,8 @@ export declare interface StdioClientTransportInterface extends MCPMessageTranspo
      *   would have read.
      * - **What the close path carries.** The frozen value is what the supervisor had received by
      *   that terminal moment, not the child's complete output.
-     *   Windows ends the tree with `taskkill /F /T`, which nothing in the child can intercept: a
+     *   After the input grace expires, Windows ends the tree with `taskkill /F /T`, which nothing
+     *   in the child can intercept: a
      *   `SIGTERM` handler never runs there, so the bytes it would have written never exist. A
      *   child that ends on its own closes its stderr first, and that tail is complete.
      *   Where that moment arrived at the supervisor's `drain` bound rather than at the child's

package/dist/src/server/index.js

@@ -1,15 +1,25 @@
+import { PROCESS_GRACE } from "@orkestrel/process";
 import { HTTPClientTransport, JSONRPC_INVALID_PARAMS, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, MCP_HANDSHAKE_VERSION, MCP_HEADER_MISMATCH, MCP_LOOKUP_PAGES, MCP_META_VERSION, MCP_METHOD_HEADER, MCP_MISSING_CAPABILITY, MCP_NAME_HEADER, MCP_PARAM_PREFIX, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_UNSUPPORTED_VERSION, MCP_WEBSOCKET_SUBPROTOCOL, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, bindServer, buildHeaderParameters, buildJSONRPCError, decodeEvent, decodeSentinel, deliverMessage, extractToolSchema, inferRequestEra, isInitializeRequest, isJSONRPCInvocation, isMCPLegacyVersion, isMCPModernVersion, isModernRequest, parseJSONRPCMessage, parseRequestContext, renderHeaderValue } from "../core/index.js";
-import { isError, isRecord, isString, parseJSON, sanitizeBudget } from "@orkestrel/contract";
+import { isError, isObject, isRecord, isString, parseJSON, sanitizeBudget } from "@orkestrel/contract";
 import { createStream, signToken, verifyToken } from "@orkestrel/server";
 import { Emitter } from "@orkestrel/emitter";
 import { WEBSOCKET_READY_OPEN, WEBSOCKET_VERSION, computeWebSocketAccept, createNodeWebSocket } from "@orkestrel/websocket";
 import { randomBytes } from "node:crypto";
 import { request } from "node:http";
 import { request as request$1 } from "node:https";
-import { Process } from "@orkestrel/process/server";
-import { PROCESS_GRACE } from "@orkestrel/process";
+import { createInterface } from "node:readline";
+import { Supervisor } from "@orkestrel/process/server";
 import { Readable } from "node:stream";
 //#region src/server/constants.ts
+/**
+* Sets the bound in milliseconds for a stdio server to exit after the client ends its input.
+*
+* @remarks
+* Gives EOF cleanup half the process supervisor's 5,000 ms signal grace before escalation gets
+* its existing full window. This bounds the MCP lifecycle's reasonable-time wait without spending
+* another full signal grace before termination. Pending input flushes share this bound.
+*/
+var MCP_STDIO_GRACE = PROCESS_GRACE / 2;
 /** Names the reverse-proxy response header controlling buffering of an SSE response. */
 var SSE_BUFFERING_HEADER = "x-accel-buffering";
 /** Names the `X-Accel-Buffering` value that disables reverse-proxy buffering. */
@@ -297,7 +307,7 @@ function writeLine(output, line) {
 * Decodes and delivers each complete newline-framed line onto a {@link
 * MCPMessageTransportEventMap} emitter — the shared per-chunk dispatch step both stdio
 * transports run their framed lines through: the server transport frames with {@link
-* extractLines}, the client transport takes its lines from the process supervisor.
+* extractLines}, the client transport frames the supervisor's stdout with Node's `readline`.
 *
 * @remarks
 * A blank line is skipped (a stray trailing newline). Every other line runs through the
@@ -719,6 +729,8 @@ var HTTPDisconnect = class {
 * handler through `MCPDispatchOptions.signal`. After every transport validation and immediately
 * before dispatch, the optional synchronous `caller` extractor reads front-middleware state; a
 * defined value is added to `MCPDispatchOptions`, while `undefined` is omitted.
+* For legacy `initialize`, the dispatch response is recorded as `initialization` before
+* JSON or SSE framing only when consumer state is an object with `'session' in context.state`.
 *
 * @typeParam TState - The consumer's opaque per-request route state type
 * @param mcp - The transport-agnostic MCP dispatcher to dispatch through
@@ -811,6 +823,9 @@ function createMCPPostHandler(mcp, options) {
 			queueMicrotask(() => void sendEventStream(response, stream));
 			return disconnect.bridge(stream);
 		}
+		if (era === "legacy" && invocation.method === "initialize" && isObject(context?.state) && "session" in context.state) {
+			if (!Reflect.set(context.state, "initialization", response)) throw new Error("MCP initialization state is not writable");
+		}
 		const status = inferStatus(response, era);
 		if (response === void 0) return new Response(null, { status });
 		if (status === 200 && streaming && acceptsEventStream(request)) {
@@ -1228,32 +1243,37 @@ var WebSocketClientTransport = class {
 *
 * @remarks
 * - **Composes `@orkestrel/process`.** `start()` builds one supervised
-*   {@link import('@orkestrel/process/server').Process} with `writable: true`, so the child's
+*   {@link import('@orkestrel/process/server').Supervisor} with `writable: true`, so the child's
 *   `stdin`/`stdout` are the JSON-RPC channel and its `stderr` is retained as bounded evidence
-*   rather than parsed as protocol. The supervisor owns spawn, framing, and termination.
-* - **Inbound (`message`).** Standard output is drained eagerly through the supervisor's
-*   `readline`-framed `lines` iterable, so a multi-byte UTF-8 sequence split across two reads is
+*   rather than parsed as protocol. The supervisor owns spawn and termination.
+* - **Inbound (`message`).** Standard output is drained eagerly through Node's `readline`,
+*   so a multi-byte UTF-8 sequence split across two reads is
 *   decoded whole and a final line written without a trailing newline still arrives. Each framed
 *   line is decoded and delivered through the shared {@link dispatchLines} helper — a well-formed
 *   {@link JSONRPCMessage} emits `message`, a malformed line emits `error` (never throws).
 * - **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
+*   through the supervisor's `deliver` 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, 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
-*   its own to get its line pump back: the stream ends under the pump rather than throwing at it.
-*   A line the supervisor had already framed behind the one being delivered is dropped rather than
+* - **`close()`** ends the child's input and waits up to {@link MCP_STDIO_GRACE} for native exit,
+*   including any pending input flush. Only after that wait does the supervisor terminate a child
+*   that remains alive. Teardown freezes `evidence`, closes the reader, and settles `exit`, then
+*   fires `close` once (idempotent).
+*   A child that exits on input end within the grace receives no termination signal, so it must
+*   end its own child processes on input end; only escalation reaches its process tree.
+*   If an `MCPClient` request `timeout` is shorter than the grace and the close outlasts that
+*   timeout, `disconnect()` rejects with `MCP transport close timed out after <timeout>ms`.
+*   The close keeps running, and a later caller joins it while it remains pending.
+*   A line already framed behind the one being delivered is dropped rather than
 *   emitted onto a transport whose teardown has begun. A `close()` issued while that teardown runs
 *   joins it rather than opening a second one, so it resolves only after `close` has fired, and a
 *   `start()` issued while it runs waits behind the same barrier, so lifetimes never overlap. A
 *   descendant can retain an inherited stdout pipe after the child exits; the supervisor's `drain`
-*   bound cuts that wait off, so this transport's `close()` settles within that bound rather than
-*   on the descendant. The termination itself belongs to the host: a POSIX host signals the
+*   bound cuts that wait off independently of the input grace. Escalation belongs to the host:
+*   a POSIX host signals the
 *   child's own process group `SIGTERM`, waits the grace window, then `SIGKILL`s through the same
 *   route, so the kill reaches grandchildren rather than orphaning them, while Windows ends the
 *   tree with `taskkill /F /T`, which nothing in the child can intercept.
@@ -1315,7 +1335,7 @@ var StdioClientTransport = class {
 		}
 		if (this.#process !== void 0 && !this.#closed) return;
 		this.#closed = false;
-		const child = new Process({
+		const child = new Supervisor({
 			command: {
 				file: this.#command,
 				arguments: [...this.#args],
@@ -1325,11 +1345,23 @@ var StdioClientTransport = class {
 			grace: PROCESS_GRACE,
 			delivery: this.#delivery,
 			writable: true
+		}, {
+			chunk: () => void 0,
+			fault: (cause) => this.#emitter.emit("error", cause),
+			close: () => reader.close(),
+			terminal: () => void 0,
+			teardown: () => reader.close()
+		});
+		const reader = createInterface({
+			input: child.stdout,
+			crlfDelay: Infinity
 		});
 		this.#process = child;
-		child.emitter.on("error", (cause) => this.#emitter.emit("error", cause));
+		reader.on("line", (line) => {
+			if (this.#closed || this.#process !== child) return;
+			dispatchLines(this.#emitter, [line]);
+		});
 		child.exit.then((exit) => this.#onExit(child, exit));
-		this.#pump(child);
 	}
 	/**
 	* Sends one newline-delimited JSON-RPC message to the live child.
@@ -1344,7 +1376,7 @@ var StdioClientTransport = class {
 	async send(message) {
 		const child = this.#closed ? void 0 : this.#process;
 		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");
+		if (!await child.deliver(Buffer.from(`${JSON.stringify(message)}\n`, "utf8"))) throw new Error("stdio transport could not deliver the message");
 	}
 	async close() {
 		if (this.#closed && this.#closing === void 0) return;
@@ -1356,17 +1388,19 @@ var StdioClientTransport = class {
 		this.#closed = true;
 		const child = this.#process;
 		if (child !== void 0) {
+			const expired = Promise.withResolvers();
+			const timer = setTimeout(expired.resolve, MCP_STDIO_GRACE);
+			try {
+				child.end();
+				await Promise.race([child.ending, expired.promise]);
+			} finally {
+				clearTimeout(timer);
+			}
 			await child.destroy();
 			this.#report(await child.exit);
 		}
 		this.#emitter.emit("close");
 	}
-	async #pump(child) {
-		for await (const line of child.lines) {
-			if (this.#closed || this.#process !== child) return;
-			dispatchLines(this.#emitter, [line]);
-		}
-	}
 	#onExit(child, exit) {
 		if (this.#process !== child) return;
 		if (this.#closed) return;
@@ -1950,8 +1984,12 @@ function createStdioServer(mcp, options) {
 *   live-session request. It then
 *   forwards a fresh `Request` carrying the buffered `text` (`next(forwarded)`) — never the
 *   already-consumed original — so the route re-reads the same body, and stamps the response
-*   with {@link MCP_SESSION_HEADER}. The entry's `touched` instant is read after that
-*   downstream response, because it means the last access: a request slower than `ttl` would
+*   with {@link MCP_SESSION_HEADER}. A candidate entry is stored and advertised only when
+*   `context.state.initialization` carries a result. An `initialize` that would mint a session
+*   stores none and advertises none when refused; a live session's header is returned unchanged.
+*   The POST handler records that dispatch response before JSON or SSE framing.
+*   The entry's `touched` instant is read after the downstream response, because it
+*   means the last access: a request slower than `ttl` would
 *   otherwise store a session that is already expired, and the write-back RE-ASKS the store, so
 *   a `DELETE` arriving while the request was suspended is not undone.
 * - **`GET {path}`.** Resolves the session the same way (no mint — only `initialize` mints);
@@ -2088,7 +2126,7 @@ function createMCPSession(options) {
 			signal: request.signal
 		}));
 		if (created !== void 0) {
-			if (!response.ok) return response;
+			if (!response.ok || context.state.initialization?.result === void 0) return response;
 			store.set(created.session.id, {
 				...created,
 				touched: clock()
@@ -2102,6 +2140,6 @@ function createMCPSession(options) {
 	};
 }
 //#endregion
-export { DEFAULT_MCP_DELIVERY, DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPDisconnect, MCPSession, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, createDuplexServerTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, dispatchLines, extractLines, inferHeaderIssue, inferHeaderTarget, inferLegacyVersion, inferParameterRefusal, inferSessionHeaderIssue, inferStatus, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath, writeLine };
+export { DEFAULT_MCP_DELIVERY, DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPDisconnect, MCPSession, MCP_STDIO_GRACE, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, createDuplexServerTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, dispatchLines, extractLines, inferHeaderIssue, inferHeaderTarget, inferLegacyVersion, inferParameterRefusal, inferSessionHeaderIssue, inferStatus, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath, writeLine };
 
 //# sourceMappingURL=index.js.map