@deepseek-ai/dsh-client-connection 0.1.2-alpha.5 → 0.1.3-alpha.2

package/lib/index.js

@@ -1,4 +1,5 @@
 import z from "@deepseek-ai/schemastery";
+import { Readable } from "node:stream";
 import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { credentialKey } from "@deepseek-ai/dsh-credentials";
 import { Service } from "@deepseek-ai/cordis";
@@ -24,48 +25,69 @@ const DEFAULT_MAX_REQUEST_BODY_BYTES = 300 * 1024 * 1024;
 /**
 * Bridge one node:http request to the fetch-shaped handler (client close
 * aborts; response bodies stream out chunk by chunk).
-* @param req - incoming node:http request (fully read before dispatch).
+* @param req - incoming node:http request.
 * @param res - node:http response the bridge writes and owns to completion.
 * @param apiHandler - fetch-shaped API carrier the request is dispatched to.
-* @param maxRequestBodyBytes - maximum body bytes buffered before dispatch.
+* @param maxRequestBodyBytes - maximum bytes buffered for a buffered route.
 */
 async function bridge(req, res, apiHandler, maxRequestBodyBytes = DEFAULT_MAX_REQUEST_BODY_BYTES) {
 	const abort = new AbortController();
 	res.on("close", () => {
 		if (!res.writableEnded) abort.abort();
 	});
-	const declaredLength = req.headers["content-length"];
-	if (declaredLength !== void 0 && Number(declaredLength) > maxRequestBodyBytes) {
-		res.writeHead(413, { connection: "close" });
-		res.end();
-		req.destroy();
-		return;
-	}
-	const chunks = [];
-	let received = 0;
-	for await (const chunk of req) {
-		const buffer = chunk;
-		received += buffer.byteLength;
-		if (received > maxRequestBodyBytes) {
+	/* v8 ignore next 2 -- node:http always sets url/method on server requests. */
+	const url = new URL(req.url ?? "/", "http://dsh.internal");
+	const method = req.method ?? "GET";
+	const headers = Object.fromEntries(Object.entries(req.headers).filter(([, value]) => typeof value === "string"));
+	const bodyMode = apiHandler.requestBodyMode({
+		method,
+		url
+	});
+	let request;
+	if (bodyMode === "buffered") {
+		const declaredLength = req.headers["content-length"];
+		if (declaredLength !== void 0 && Number(declaredLength) > maxRequestBodyBytes) {
 			res.writeHead(413, { connection: "close" });
 			res.end();
 			req.destroy();
 			return;
 		}
-		chunks.push(buffer);
-	}
-	/* v8 ignore next 3 -- `??` arms: node:http always sets url/method on server
-	requests; the fields are only optional on the client-side IncomingMessage type */
-	const request = new Request(new URL(req.url ?? "/", "http://dsh.internal"), {
-		method: req.method ?? "GET",
-		headers: Object.fromEntries(Object.entries(req.headers).filter(([, v]) => typeof v === "string")),
-		...chunks.length > 0 ? { body: Buffer.concat(chunks) } : {},
-		signal: abort.signal
+		const chunks = [];
+		let received = 0;
+		for await (const chunk of req) {
+			const buffer = chunk;
+			received += buffer.byteLength;
+			if (received > maxRequestBodyBytes) {
+				res.writeHead(413, { connection: "close" });
+				res.end();
+				req.destroy();
+				return;
+			}
+			chunks.push(buffer);
+		}
+		request = new Request(url, {
+			method,
+			headers,
+			...chunks.length > 0 ? { body: Buffer.concat(chunks) } : {},
+			signal: abort.signal
+		});
+	} else request = new Request(url, {
+		method,
+		headers,
+		body: Readable.toWeb(req),
+		signal: abort.signal,
+		duplex: "half"
 	});
 	const response = await apiHandler.fetch(request);
-	res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+	const requestUnread = bodyMode === "streaming" && !req.readableEnded;
+	const responseHeaders = Object.fromEntries(response.headers.entries());
+	res.writeHead(response.status, requestUnread ? {
+		...responseHeaders,
+		connection: "close"
+	} : responseHeaders);
 	if (response.body === null) {
 		res.end();
+		if (requestUnread) req.destroy();
 		return;
 	}
 	for await (const chunk of response.body) if (!res.write(chunk)) await new Promise((resolve) => {
@@ -78,6 +100,7 @@ async function bridge(req, res, apiHandler, maxRequestBodyBytes = DEFAULT_MAX_RE
 		res.once("close", done);
 	});
 	res.end();
+	if (requestUnread) req.destroy();
 }
 //#endregion
 //#region lib/types/loopback-hostname.js
@@ -545,20 +568,27 @@ var HostConnectionService = class extends Service {
 	* @returns Fetch handler that selects one owner or returns 404.
 	*/
 	createSharedFetchHandler(channel) {
-		return { fetch: (request) => {
-			const pathname = new URL(request.url).pathname;
-			const route = this.fetchRoutes.get(pathname);
-			if (route?.methods.has(request.method) === true) return route.fetch(request);
-			const endpoint = endpointFromPath(channel, pathname);
-			const interceptor = this.interceptors.get(channel);
-			if (endpoint === void 0 || interceptor === void 0 || !interceptor.matches(endpoint)) return Promise.resolve(new Response("not found", { status: 404 }));
-			return interceptor.fetchHandler.fetch(request);
-		} };
+		return {
+			requestBodyMode: ({ method, url }) => {
+				const route = this.fetchRoutes.get(url.pathname);
+				return route?.methods.has(method) === true ? route.requestBody : "buffered";
+			},
+			fetch: (request) => {
+				const pathname = new URL(request.url).pathname;
+				const route = this.fetchRoutes.get(pathname);
+				if (route?.methods.has(request.method) === true) return route.fetch(request);
+				const endpoint = endpointFromPath(channel, pathname);
+				const interceptor = this.interceptors.get(channel);
+				if (endpoint === void 0 || interceptor === void 0 || !interceptor.matches(endpoint)) return Promise.resolve(new Response("not found", { status: 404 }));
+				return interceptor.fetchHandler.fetch(request);
+			}
+		};
 	}
 	registerFetchRoute(owner, route) {
 		assertFetchRoute(route);
 		const registered = {
 			methods: new Set(route.methods),
+			requestBody: route.requestBody,
 			fetch: route.fetch
 		};
 		return owner.effect(() => {
@@ -603,31 +633,34 @@ var HostConnectionService = class extends Service {
 	}
 };
 function rpcFetchHandler(channel, handler) {
-	return { async fetch(request) {
-		const endpoint = endpointFromPath(channel, new URL(request.url).pathname);
-		if (request.method !== "POST" || endpoint === void 0) return new Response("not found", { status: 404 });
-		if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response("content type must be application/json", { status: 415 });
-		let body;
-		try {
-			body = await request.json();
-		} catch {
-			return new Response("body is not JSON", { status: 400 });
-		}
-		const envelope = clientRequestSchema.safeParse(body);
-		if (!envelope.success) return invalidEnvelopeResponse(body, envelope.error.issues);
-		const message = envelope.data;
-		if (message.method !== endpoint) return errorResponse(message.rpcId, {
-			code: "gateway/bad-request",
-			message: `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`,
-			details: { issues: [] }
-		});
-		try {
-			const result = await handler(endpoint, message.payload, request.signal);
-			return fullResponse(message.rpcId, result);
-		} catch (error) {
-			return new Response(`handler failure: ${String(error)}`, { status: 500 });
+	return {
+		requestBodyMode: () => "buffered",
+		async fetch(request) {
+			const endpoint = endpointFromPath(channel, new URL(request.url).pathname);
+			if (request.method !== "POST" || endpoint === void 0) return new Response("not found", { status: 404 });
+			if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") return new Response("content type must be application/json", { status: 415 });
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return new Response("body is not JSON", { status: 400 });
+			}
+			const envelope = clientRequestSchema.safeParse(body);
+			if (!envelope.success) return invalidEnvelopeResponse(body, envelope.error.issues);
+			const message = envelope.data;
+			if (message.method !== endpoint) return errorResponse(message.rpcId, {
+				code: "gateway/bad-request",
+				message: `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`,
+				details: { issues: [] }
+			});
+			try {
+				const result = await handler(endpoint, message.payload, request.signal);
+				return fullResponse(message.rpcId, result);
+			} catch (error) {
+				return new Response(`handler failure: ${String(error)}`, { status: 500 });
+			}
 		}
-	} };
+	};
 }
 function invalidEnvelopeResponse(body, issues) {
 	const rawId = body?.rpcId;
@@ -666,6 +699,28 @@ function assertFetchRoute(route) {
 	if (new Set(route.methods).size !== route.methods.length) throw new Error(`connection: exact Fetch route ${JSON.stringify(route.path)} repeats a method`);
 }
 //#endregion
+//#region lib/types/recovery-config.js
+/** Shared validation for Host-configured and browser-local connection recovery. */
+const MAX_TIMER_MS = 2147483647;
+/** Schema shared by the Host plugin and the Client's recovery input parser. */
+const ConnectionRecoveryConfigSchema = z.object({
+	backoffBaseMs: z.natural().min(1).max(MAX_TIMER_MS).default(500),
+	backoffFactor: z.number().min(1).max(Number.MAX_VALUE).default(2),
+	backoffMaxMs: z.natural().min(1).max(MAX_TIMER_MS).default(1e4),
+	generationReadyWarnMs: z.natural().min(1).max(MAX_TIMER_MS).default(3e3),
+	generationReadyTimeoutMs: z.natural().min(1).max(MAX_TIMER_MS).default(15e3)
+});
+/**
+* Validate recovery input and supply every timing default before starting work.
+* @param config - Host configuration, page bootstrap data, or direct loop options.
+* @returns validated, complete recovery timing.
+*/
+function resolveConnectionConfig(config = {}) {
+	const resolved = ConnectionRecoveryConfigSchema(config);
+	if (!Number.isFinite(resolved.backoffFactor)) throw new RangeError("connection recovery backoffFactor must be finite");
+	return resolved;
+}
+//#endregion
 //#region lib/types/index.js
 /** Stable Cordis plugin name. */
 const name = "client-connection";
@@ -680,6 +735,7 @@ function assertImageBodyCapacity(ctx, maxRequestBodyBytes) {
 /** Services required before providing Connection. */
 const inject = ["webServer", "credentials"];
 const Config = z.object({
+	recovery: ConnectionRecoveryConfigSchema.default({}),
 	trustedHosts: z.array(String).default([]),
 	cookieMaxAgeDays: z.natural().min(1).default(30),
 	maxRequestBodyBytes: z.natural().min(1).default(DEFAULT_MAX_REQUEST_BODY_BYTES)
@@ -692,12 +748,20 @@ const Config = z.object({
 * @param config - resolved plugin config (schema defaults applied).
 */
 async function apply(ctx, config) {
+	const recovery = resolveConnectionConfig(config?.recovery);
 	const trustedHosts = config?.trustedHosts ?? [];
 	const cookieMaxAgeDays = config?.cookieMaxAgeDays ?? 30;
 	const maxRequestBodyBytes = config?.maxRequestBodyBytes ?? 314572800;
 	for (const entry of trustedHosts) assertTrustedAuthority(entry);
 	assertImageBodyCapacity(ctx, maxRequestBodyBytes);
 	const connection = new HostConnectionService(ctx, trustedHosts, await BrowserAuth.create(ctx.root, ctx.credentials, cookieMaxAgeDays));
+	ctx.on("webserver/index-inject", (table) => {
+		table.push({
+			kind: "global",
+			name: "__DSH_CONNECTION_RECOVERY__",
+			value: recovery
+		});
+	});
 	const fetchHandler = connection.createSharedFetchHandler(API_PATH);
 	const route = {
 		kind: "prefix",

package/lib/types/client/connection.d.ts

@@ -1,3 +1,6 @@
+/** Connection generation readiness, cancellation, and continuous recovery. */
+import { type ConnectionRecoveryConfig } from '../recovery-config.ts';
+export type { ConnectionRecoveryConfig } from '../recovery-config.ts';
 /** Stable Host facts delivered by one established Remote event generation. */
 export interface ConnectionHostInfo {
     /** Host account home used only to abbreviate displayed filesystem paths. */
@@ -10,17 +13,6 @@ export interface ConnectionGeneration {
     /** Host facts carried by this generation's opening frame. */
     readonly host: ConnectionHostInfo;
 }
-/** Reconnect/backoff tunables. All fields are optional; defaults are below. */
-export interface ConnectionConfig {
-    /** First-retry backoff cap in ms (jittered: actual delay is cap/2..cap). */
-    backoffBaseMs?: number;
-    /** Exponential growth factor per failed attempt; values at or below 1 make the base tier final. */
-    backoffFactor?: number;
-    /** Upper bound for the backoff cap in ms. */
-    backoffMaxMs?: number;
-    /** Maximum wait for the registered generation source's ready signal. */
-    generationReadyTimeoutMs?: number;
-}
 /** Connection lifecycle state published after the first attempt has an outcome. */
 export type ConnectionState = 'connected' | 'disconnected' | 'connecting';
 /** Connection-generation callbacks owned by API Gateway. */
@@ -35,7 +27,8 @@ export interface ConnectionSinks {
 /**
  * One long-lived source defining a Connection generation. The source must
  * attach its incremental listeners before calling `ready`, then remain pending
- * until the generation is lost or `signal` aborts.
+ * until the generation is lost or `signal` aborts. On abort it must stop
+ * delivery, release its resources, and settle before a replacement can start.
  * @param signal - cancellation for the current generation.
  * @param ready - one-shot report that incremental delivery is attached.
  * @returns a promise settling only when this generation ends or fails.
@@ -58,7 +51,7 @@ export declare class ConnectionController {
     private networkAvailable;
     private lastState;
     private readonly config;
-    constructor(source: ConnectionGenerationSource, sinks?: ConnectionSinks, config?: ConnectionConfig);
+    constructor(source: ConnectionGenerationSource, sinks?: ConnectionSinks, config?: ConnectionRecoveryConfig);
     /** Idempotent: begin the connect/pump/reconnect loop. */
     start(): void;
     /** Stop the loop and abort the current generation source. */
@@ -72,7 +65,8 @@ export declare class ConnectionController {
     setNetworkAvailable(available: boolean): void;
     private backoffCap;
     private backoffDelay;
-    private isFinalBackoffTier;
+    /** Re-read retry inputs after a potentially reentrant state sink. */
+    private isRetryInterrupted;
     /** Read through a method: stop() flips the flag across awaits, so narrowing from the loop condition must not stick. */
     private isRunning;
     /** Re-read both mutable liveness guards after a potentially reentrant sink. */

package/lib/types/client/fixture.d.ts

@@ -1,4 +1,35 @@
+import { LlmAttemptId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionSeqCursor } from '@deepseek-ai/dsh-session/types';
+import type { JsonValue } from '@deepseek-ai/dsh-util-values';
 import type { ClientConnectionRpc } from '../rpc.ts';
+/** Assistant frame emitted by the standalone fixture; tests pin it to the controller wire type. */
+export type FixtureAssistantStreamFrame = {
+    readonly type: 'start';
+    readonly attemptId: ReturnType<typeof LlmAttemptId>;
+    readonly revision: number;
+    readonly startedAfterSeq: SessionSeqCursor;
+    readonly turn: number;
+    readonly step: number;
+} | {
+    readonly type: 'chunk';
+    readonly attemptId: ReturnType<typeof LlmAttemptId>;
+    readonly revision: number;
+    readonly index: number;
+    readonly time: number;
+    readonly chunk: JsonValue;
+} | {
+    readonly type: 'end';
+    readonly attemptId: ReturnType<typeof LlmAttemptId>;
+    readonly revision: number;
+    readonly index: number;
+    readonly outcome: {
+        readonly kind: 'committed';
+        readonly eventType: 'assistant/message' | 'assistant/attempt';
+        readonly seq: number;
+    } | {
+        readonly kind: 'abandoned';
+    };
+};
 /** Deterministic fixture branches used by keyless Web assembly tests. */
 export interface FixtureOptions {
     /** Start with no real Workspace or Session. */

package/lib/types/client/index.d.ts

@@ -1,9 +1,6 @@
-/**
- * Browser wire client. The plugin selects fixture or HTTP transport, provides
- * the shared API client, and lets API Gateway own the connection loop.
- */
+/** Browser wire client: Remote transport and connection generations. */
 import type { Context } from '@deepseek-ai/cordis';
-import { type ConnectionConfig, type ConnectionGeneration, type ConnectionGenerationSource, type ConnectionSinks, type ConnectionState } from './connection.ts';
+import { type ConnectionRecoveryConfig, type ConnectionGeneration, type ConnectionGenerationSource, type ConnectionSinks, type ConnectionState } from './connection.ts';
 import { type RpcFetch, type RpcStreamOpen } from './rpc.ts';
 import type { ClientConnectionRpc } from '../rpc.ts';
 declare module '@deepseek-ai/cordis' {
@@ -18,7 +15,7 @@ declare module '@deepseek-ai/cordis' {
 }
 export type { MessageId, RpcRequest, RpcResponse, RpcResult, ClientRequest, ServerResponse, RpcMessage, SessionId, SessionEvent, ContentBlock, StreamChunk, } from './api.ts';
 export { RpcId, transportError, } from './api.ts';
-export type { ConnectionConfig, ConnectionGeneration, ConnectionGenerationSource, ConnectionHostInfo, ConnectionSinks, ConnectionState, } from './connection.ts';
+export type { ConnectionRecoveryConfig, ConnectionGeneration, ConnectionGenerationSource, ConnectionHostInfo, ConnectionSinks, ConnectionState, } from './connection.ts';
 export type { ClientConnectionRpc, ConnectionRpcFailure, ConnectionRpcResult, } from '../rpc.ts';
 export type { RpcFetch } from './rpc.ts';
 /** Observable identity and Host facts for the active connection generation. */
@@ -65,9 +62,8 @@ export interface ClientTransportHooks {
     ownsHost?: boolean;
 }
 /**
- * The ctx.connection service API: the API client plus a one-shot controller
- * starter. API Gateway supplies generation readiness and reset callbacks;
- * Connection stays independent of downstream domain state.
+ * The ctx.connection service API. API Gateway supplies generation readiness
+ * and reset callbacks; Connection stays independent of downstream domain state.
  */
 export interface ConnectionHandle {
     /**
@@ -95,10 +91,10 @@ export interface ConnectionHandle {
      * Start the connect/reconnect loop with the consumer's state callbacks.
      * API Gateway owns the loop; a second call throws.
      * @param sinks - connection-state callbacks.
-     * @param config - reconnect timing tunables.
+     * @param config - explicit timing overrides; omitted fields use Host bootstrap timing.
      * @returns lifecycle controls for the loop.
      */
-    start(sinks: ConnectionSinks, config?: ConnectionConfig): ConnectionLoop;
+    start(sinks: ConnectionSinks, config?: ConnectionRecoveryConfig): ConnectionLoop;
 }
 /** Controls retained by the sole owner of a running connection loop. */
 export interface ConnectionLoop {
@@ -106,7 +102,7 @@ export interface ConnectionLoop {
     stop(): void;
 }
 /**
- * Client plugin body: pick the api by page mode and provide ctx.connection.
+ * Client plugin body: pick physical carriers by page mode and provide ctx.connection.
  * @param ctx - client cordis context.
  */
 export declare function apply(ctx: Context): void;

package/lib/types/http-bridge.d.ts

@@ -3,27 +3,19 @@
  * web carrier; the fetch-shaped handler itself is transport-agnostic).
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ConnectionFetchHandler } from './rpc.ts';
 /** Default carrier cap for all HTTP RPC bodies: sized for the default
  * aggregate image limit (200 MiB) after base64 expansion plus envelope
  * headroom (~267.7 MiB required), rounded up for slack. The bridge buffers
  * each body in memory, so this cap is also the per-request resident bound. */
 export declare const DEFAULT_MAX_REQUEST_BODY_BYTES: number;
-/** Transport-independent request handler consumed by the Host HTTP bridge. */
-export interface FetchHandler {
-    /**
-     * Handle one standard Fetch request.
-     * @param request - request produced by the active transport bridge.
-     * @returns complete or streaming Fetch response.
-     */
-    fetch(request: Request): Promise<Response>;
-}
 /**
  * Bridge one node:http request to the fetch-shaped handler (client close
  * aborts; response bodies stream out chunk by chunk).
- * @param req - incoming node:http request (fully read before dispatch).
+ * @param req - incoming node:http request.
  * @param res - node:http response the bridge writes and owns to completion.
  * @param apiHandler - fetch-shaped API carrier the request is dispatched to.
- * @param maxRequestBodyBytes - maximum body bytes buffered before dispatch.
+ * @param maxRequestBodyBytes - maximum bytes buffered for a buffered route.
  */
-export declare function bridge(req: IncomingMessage, res: ServerResponse, apiHandler: FetchHandler, maxRequestBodyBytes?: number): Promise<void>;
+export declare function bridge(req: IncomingMessage, res: ServerResponse, apiHandler: ConnectionFetchHandler, maxRequestBodyBytes?: number): Promise<void>;
 //# sourceMappingURL=http-bridge.d.ts.map

package/lib/types/index.d.ts

@@ -1,7 +1,8 @@
 /** Host HTTP bridge for browser-client RPC. */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-export type { ConnectionFetchMethod, ConnectionFetchHandler, ConnectionFetchRoute, ConnectionIndexRequest, ConnectionIndexResponse, ConnectionRpcEndpointMatcher, ConnectionRpcFailure, ConnectionRpcHandler, ConnectionRequestRejection, ConnectionRpcResult, ConnectionTrustRequest, ClientRequest, HostConnectionHandle, HostConnectionFetch, HostConnectionRpc, RpcMessage, ServerResponse, } from './rpc.ts';
+import { type ConnectionRecoveryConfig } from './recovery-config.ts';
+export type { ConnectionFetchMethod, ConnectionFetchHandler, ConnectionFetchRoute, ConnectionIndexRequest, ConnectionIndexResponse, ConnectionRpcEndpointMatcher, ConnectionRpcFailure, ConnectionRpcHandler, ConnectionRequestRejection, ConnectionRpcResult, ConnectionRequestBodyMode, ConnectionTrustRequest, ClientRequest, HostConnectionHandle, HostConnectionFetch, HostConnectionRpc, RpcMessage, ServerResponse, } from './rpc.ts';
 export { RpcId, transportError } from './rpc.ts';
 export { clientRequestSchema, rpcErrorSchema, rpcIdSchema, rpcMessageSchema, rpcResultSchema, serverResponseSchema, } from './rpc-schema.ts';
 export { HostConnectionService } from './rpc-host.ts';
@@ -10,8 +11,10 @@ export { API_PATH } from './api-path.ts';
 export declare const name = "client-connection";
 /** Services required before providing Connection. */
 export declare const inject: string[];
-/** Plugin config: the deployment's non-loopback serving authorities. */
+/** Browser authentication, request limits, and connection recovery configuration. */
 export interface ConnectionConfig {
+    /** Browser recovery timing, injected into each served page. */
+    recovery?: ConnectionRecoveryConfig;
     /**
      * Authorities this deployment serves beyond loopback: exact `host:port`, or
      * port-less `host` matching any port. The /api trust fence refuses any

package/lib/types/recovery-config.d.ts

@@ -0,0 +1,27 @@
+/** Shared validation for Host-configured and browser-local connection recovery. */
+import z from '@deepseek-ai/schemastery';
+/** Timing for generation readiness and automatic reconnection. */
+export interface ConnectionRecoveryConfig {
+    /** First-retry delay cap in ms; actual delay is 50–100% of the cap. Default: 500. */
+    backoffBaseMs?: number;
+    /** Finite growth factor of at least 1 per failed attempt; 1 keeps a fixed cap. Default: 2. */
+    backoffFactor?: number;
+    /** Maximum retry delay cap in ms; retries continue at this cap. Default: 10000. */
+    backoffMaxMs?: number;
+    /**
+     * Delay before reporting a slow handshake, without cancelling it. Default: 3000.
+     * Omitted when readiness, failure, cancellation, or the hard deadline occurs first.
+     */
+    generationReadyWarnMs?: number;
+    /** Deadline in ms for readiness, including physical connection setup. Default: 15000. */
+    generationReadyTimeoutMs?: number;
+}
+/** Schema shared by the Host plugin and the Client's recovery input parser. */
+export declare const ConnectionRecoveryConfigSchema: z<ConnectionRecoveryConfig>;
+/**
+ * Validate recovery input and supply every timing default before starting work.
+ * @param config - Host configuration, page bootstrap data, or direct loop options.
+ * @returns validated, complete recovery timing.
+ */
+export declare function resolveConnectionConfig(config?: unknown): Required<ConnectionRecoveryConfig>;
+//# sourceMappingURL=recovery-config.d.ts.map

package/lib/types/rpc.d.ts

@@ -77,13 +77,17 @@ export type ConnectionRpcHandler = (endpoint: string, payload: unknown, signal:
 /** Synchronous ownership test for one endpoint on a shared RPC channel. */
 export type ConnectionRpcEndpointMatcher = (endpoint: string) => boolean;
 /** HTTP methods supported by exact Fetch routes on the shared API channel. */
-export type ConnectionFetchMethod = 'GET' | 'HEAD';
+export type ConnectionFetchMethod = 'GET' | 'HEAD' | 'POST';
+/** How the node:http bridge presents one request body to its Fetch route. */
+export type ConnectionRequestBodyMode = 'buffered' | 'streaming';
 /** One exact, transport-independent Fetch route owned by a Host feature. */
 export interface ConnectionFetchRoute {
     /** Absolute path below `/api`; query parameters remain available on the request URL. */
     readonly path: string;
     /** Methods this route owns. Other methods continue through normal shared-channel dispatch. */
     readonly methods: readonly ConnectionFetchMethod[];
+    /** Buffered requests obey the configured JSON cap; streaming requests arrive with backpressure and no aggregate cap. */
+    readonly requestBody: ConnectionRequestBodyMode;
     /** Handle one request after the physical carrier has applied its trust and authentication policy. */
     readonly fetch: (request: Request) => Promise<Response>;
 }
@@ -149,6 +153,15 @@ export interface HostConnectionHandle {
 }
 /** Transport-independent Fetch handler used by HTTP and worker carriers. */
 export interface ConnectionFetchHandler {
+    /**
+     * Resolve body handling before the bridge reads any request bytes.
+     * @param request - request method and URL available from node:http headers.
+     * @returns the registered route's body handling mode.
+     */
+    requestBodyMode(request: {
+        readonly method: string;
+        readonly url: URL;
+    }): ConnectionRequestBodyMode;
     /**
      * Dispatch one already-authenticated request.
      * @param request - Fetch request below the shared channel.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-connection",
   "description": "Authenticated RPC transport, generation lifecycle, and browser fixture",
-  "version": "0.1.2-alpha.5",
+  "version": "0.1.3-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -35,7 +35,7 @@
   "license": "MIT",
   "dependencies": {
     "zod": "^4.4.3",
-    "@deepseek-ai/dsh-credentials": "^0.1.2-alpha.5",
+    "@deepseek-ai/dsh-credentials": "^0.1.3-alpha.2",
     "@deepseek-ai/schemastery": "^3.18.2"
   },
   "files": [
@@ -48,15 +48,16 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-attachment": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-commands": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-host-directory-picker": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-tool-todo": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-util-values": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session": "^0.1.2-alpha.5"
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-attachment": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-brand": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-commands": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-host-directory-picker": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-settings": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-tool-todo": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-util-values": "^0.1.3-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.3-alpha.2"
   }
 }