@defjs/core 0.4.0 → 0.6.0

package/index.js

@@ -1,23 +1,3 @@
-// src/client/command.ts
-const COMMAND_TYPE = Symbol.for("defjs.command.type");
-const HTTP_COMMAND = Symbol.for("defjs.command.http");
-const EVENT_STREAM_COMMAND = Symbol.for("defjs.command.event-stream");
-const WEB_SOCKET_COMMAND = Symbol.for("defjs.command.web-socket");
-/** The command's own runner, so `client.execute` never imports a transport the app does not use. */
-const COMMAND_EXECUTE = Symbol.for("defjs.command.execute");
-function commandTypeOf(value) {
-	if (typeof value !== "object" || value === null || !(COMMAND_TYPE in value)) return;
-	return value[COMMAND_TYPE];
-}
-function isHttpCommand(value) {
-	return commandTypeOf(value) === HTTP_COMMAND;
-}
-function isEventStreamCommand(value) {
-	return commandTypeOf(value) === EVENT_STREAM_COMMAND;
-}
-function isWebSocketCommand(value) {
-	return commandTypeOf(value) === WEB_SOCKET_COMMAND;
-}
 // src/client/config.ts
 const PLATFORM_FETCH = globalThis.fetch;
 const PLATFORM_FETCH_HANDLE = PLATFORM_FETCH?.bind(globalThis);
@@ -61,149 +41,498 @@ function createClientConfig() {
 	};
 }
 // src/client/client.ts
+/**
+* Internal symbol key for a client's base configuration and request options.
+*
+* Application code passes the client to an operation. It does not call the client or read this property.
+*
+* @group client
+*/
 const CLIENT = Symbol("Client");
+const KNOWN_FIELDS = [
+	"signal",
+	"onUploadProgress",
+	"onDownloadProgress",
+	"beforeConnect",
+	"protocols",
+	"heartbeat",
+	"reconnect"
+];
+function snapshot(patch) {
+	const out = {};
+	if (patch === void 0) return out;
+	for (const key of KNOWN_FIELDS) {
+		const value = patch[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function createClientValue(config, options) {
+	return { [CLIENT]: {
+		config,
+		options
+	} };
+}
 /**
-* Creates a Defjs client from option helpers.
+* Creates a Defjs {@link DerivableClient} from option helpers.
 *
-* Options apply in order: a later option overwrites an earlier one for the same setting, and interceptors accumulate. Prefer creating the client inside the request boundary when interceptors close over auth or tenants. Default HTTP/SSE fetch availability is checked when the interceptor chain invokes transport.
+* Options apply in order: a later option overwrites an earlier one for the same setting, and interceptors accumulate. Prefer creating the client inside the request boundary when interceptors close over auth or tenants. Default HTTP/SSE fetch availability is checked when an operation invokes transport.
+*
+* The returned factory is a function. Calling it with {@link RequestOptions} returns a {@link Client} value for one call and performs no I/O; see {@link DerivableClient} for the snapshot rules. The factory itself is also a `Client` and carries no request options, so it can be passed to an operation directly. The base configuration is shared by every client value and is not frozen at runtime. It is fixed by convention: nothing in the library changes it, and applications should not either.
 *
 * @param options - Client option helpers such as `withEndpoint`.
-* @returns A client that can `execute` HTTP, SSE, and WebSocket commands.
+* @returns A callable factory that carries the resolved base configuration.
 *
 * @group client
+* @see {@link DerivableClient}
 * @see {@link Client}
 * @see {@link ClientOption}
+* @see {@link RequestOptions}
 * @exampleFile examples/api/create-client.ts#example
 */
 function createClient(...options) {
-	const conf = createClientConfig();
-	for (const option of options) option(conf);
-	function execute(command, options) {
-		if (isHttpCommand(command) || isEventStreamCommand(command) || isWebSocketCommand(command)) return command[COMMAND_EXECUTE](conf, command, options);
-		return Promise.reject(/* @__PURE__ */ new Error("Unsupported command"));
-	}
-	return {
-		[CLIENT]: conf,
-		execute
+	const config = createClientConfig();
+	for (const option of options) option(config);
+	function factory(patch) {
+		return createClientValue(config, snapshot(patch));
+	}
+	factory[CLIENT] = {
+		config,
+		options: {}
 	};
+	return factory;
 }
-// src/struct/symbols.ts
-const DEFINITION = Symbol.for("defjs.struct.definition");
-const OMIT = Symbol("defjs.struct.omit");
+// src/client/option.ts
 /**
-* Stands in for a parsed value when parsing fails; the issue waits in the slot that `failure()` fills.
-* Not in the symbol registry, so no input value can ever equal it.
+* Sets the valid absolute base URL prepended to relative request paths.
+*
+* The default is an empty string, so execution requires an explicit endpoint. Its pathname is kept as a directory; its query and hash are discarded. For WebSocket operations, an `http:` base becomes `ws:` and `https:` becomes `wss:`.
+*
+* A missing, relative, or invalid endpoint, or an illegal request path, fails with `REQ_BUILD_FAILED` during building, before any interceptor or transport runs, even when an interceptor would short-circuit. HTTP, SSE, and WebSocket share this rule. The resolved request must keep the base origin and stay under its directory; C0 control characters (including tab, CR, and LF), backslashes, `?`, `#`, and directory escapes in a path are rejected. Scheme-like and protocol-relative forms are rejected even with leading spaces; a plain inner space is allowed and sent as `%20`. An interceptor's final `req.endpoint` is checked against its final `req.baseEndpoint` with the same rule, but it may deliberately replace the base with another valid absolute URL. Deterministic URL errors are never retried.
+*
+* @param endpoint - Absolute base endpoint. Missing or invalid endpoints fail request building.
+* @returns An option that writes `config.endpoint`.
+* @group client
 */
-const FAILED = Symbol("defjs.struct.failed");
+function withEndpoint(endpoint) {
+	return (config) => {
+		config.endpoint = endpoint;
+	};
+}
 /**
-* Type-only export of the internal enumerable tag key on objects produced while parsing endpoint input, used by the outbound encoder.
+* Sets static default headers for HTTP and SSE requests built by this client.
 *
-* `STRUCT` is exported as a **type** only (`export type { STRUCT }`). `@defjs/core` has no runtime `STRUCT` export, so `import { STRUCT } from '@defjs/core'` fails to compile and gives no value.
+* WebSocket connections do not use them. The `HeadersInit` is copied into a `Headers` object when the option is applied. A later call replaces the earlier headers instead of merging.
 *
-* It marks those objects so the outbound encoder knows which struct produced them. Response decoding and `struct.parse` leave it unset. The symbol is internal to the outbound encoder; application code should not depend on it.
+* Headers returned by a request builder replace a default of the same name. The first value for that name replaces the default; later values in the same array append only to that replacement. A scalar or a `Headers` instance also replaces. Other default names stay.
 *
-* @internal
-* @group struct
+* Per-request or computed credentials, such as a refreshed Bearer token or an HMAC signature, belong in an interceptor, because they need the serialized body or a refreshed credential.
+*
+* @param headers - `HeadersInit` bag cloned onto the client config.
+* @returns An option that writes `config.headers`.
+* @group client
 */
-const STRUCT = Symbol.for("defjs.struct.STRUCT");
-// src/struct/guards.ts
-const KNOWN_KINDS = /* @__PURE__ */ new Set([
-	"any",
-	"array",
-	"arrayBuffer",
-	"bigint",
-	"blob",
-	"boolean",
-	"date",
-	"discriminatedUnion",
-	"enum",
-	"file",
-	"intersection",
-	"literal",
-	"null",
-	"number",
-	"object",
-	"or",
-	"record",
-	"string",
-	"tuple",
-	"unknown"
-]);
-function isStruct(value) {
-	if (typeof value !== "object" || value === null || !Object.hasOwn(value, DEFINITION)) return false;
-	const definition = value[DEFINITION];
-	if (typeof definition !== "object" || definition === null) return false;
-	if (!KNOWN_KINDS.has(definition.kind)) return false;
-	const flags = definition.flags;
-	return typeof flags === "object" && flags !== null && typeof flags.nullable === "boolean" && typeof flags.optional === "boolean";
+function withHeaders(headers) {
+	return (config) => {
+		config.headers = new Headers(headers);
+	};
 }
-// src/struct/guide.ts
-const GUIDE_SET = Symbol.for("defjs.struct.guideSet");
-function isGuideSet(value) {
-	return typeof value === "object" && value !== null && value[GUIDE_SET] === true;
+/**
+* Appends interceptors to the client interceptor chain.
+*
+* Calling it again appends more; it never replaces earlier ones. The first registered interceptor is the outermost layer. HTTP, SSE, and WebSocket interceptors can be mixed in one call. When an operation runs, only the interceptors of that transport run, in their registration order.
+*
+* @param interceptors - Interceptors applied in registration order.
+* @returns An option that pushes onto `config.interceptors`.
+* @group client
+*/
+function withInterceptors(...interceptors) {
+	return (config) => {
+		config.interceptors.push(...interceptors);
+	};
 }
-function guideTag(members) {
-	const unique = [];
-	for (const member of members) if (!unique.includes(member)) unique.push(member);
-	if (unique.length === 0) return;
-	if (unique.length === 1) return unique[0];
-	return {
-		[GUIDE_SET]: true,
-		members: unique
+/**
+* Replaces query encoding for HTTP, SSE, and WebSocket requests.
+*
+* `serializer(query)` receives the encoded wire object: aliases applied, `Date` as an ISO string, `bigint` as a string. Nested objects and arrays are kept as they are. It must return the query string without a leading `?`. The string is used verbatim.
+*
+* It is not called when the request has no query. A builder that returns `URLSearchParams` skips it. Without this option, queries use `URLSearchParams`: arrays repeat keys and a nested object fails.
+*
+* @param serializer - Function that turns an encoded query object into a string.
+* @returns An option that sets `config.querySerializer`.
+* @group client
+*/
+function withQuerySerializer(serializer) {
+	return (config) => {
+		config.querySerializer = serializer;
 	};
 }
-function guideMembers(guide) {
-	return isGuideSet(guide) ? guide.members : [guide];
+/**
+* Replaces the Fetch-compatible function used for HTTP requests.
+*
+* The default is the platform `fetch`. `fetchImpl` is a {@link FetchHandle}, so a test double does not need host extras such as `fetch.preconnect`. It only affects HTTP. SSE uses {@link withSSEHandle}.
+*
+* @param fetchImpl - `(input, init?) => Promise<Response>`. Not `typeof fetch`, so
+*   a mock does not need host extras such as `preconnect`.
+* @returns An option that sets `config.http.handle`.
+* @group client
+*/
+function withHTTPHandle(fetchImpl) {
+	return (config) => {
+		config.http.handle = fetchImpl;
+	};
 }
-function combineGuides(left, right) {
-	if (!left) return right;
-	if (!right) return left;
-	return guideTag([...guideMembers(left), ...guideMembers(right)]);
+/**
+* Replaces the Fetch-compatible function used to open SSE event streams.
+*
+* The default is the platform `fetch`. `fetchImpl` is a {@link FetchHandle}. It only affects SSE. HTTP uses {@link withHTTPHandle}.
+*
+* @param fetchImpl - `(input, init?) => Promise<Response>`. Not `typeof fetch`, so
+*   a mock does not need host extras such as `preconnect`.
+* @returns An option that sets `config.sse.handle`.
+* @group client
+*/
+function withSSEHandle(fetchImpl) {
+	return (config) => {
+		config.sse.handle = fetchImpl;
+	};
 }
-function readOwnGuide(value, guides) {
-	const tag = guides?.get(value) ?? value[STRUCT];
-	if (isGuideSet(tag)) return tag;
-	if (!isStruct(tag)) return;
-	const kind = tag[DEFINITION].kind;
-	if (kind === "object" || kind === "record") return tag;
+/**
+* Replaces the WebSocket constructor used for socket connections.
+*
+* The default is `globalThis.WebSocket`. `WebSocketImpl` is a {@link WebSocketHandleConstructor} that returns a {@link WebSocketHandle}. If no constructor is available, a WebSocket operation fails with an `ENV_UNSUPPORTED` fault.
+*
+* @param WebSocketImpl - Constructor that returns a `WebSocketHandle`.
+* @returns An option that sets `config.webSocket.handle`.
+* @group client
+*/
+function withWebSocketHandle(WebSocketImpl) {
+	return (config) => {
+		config.webSocket.handle = WebSocketImpl;
+	};
 }
-/** Tag a null-prototype node this parse just created. Enumerable so object spread keeps its guide. */
-function tagOwnNode(value, tag) {
-	value[STRUCT] = tag;
+/**
+* Runs a hook before the initial WebSocket connect and before every reconnect.
+*
+* The hook type is:
+*
+* ```ts
+* (context: { attempt: number; signal: AbortSignal }) => void | Promise<void>
+* ```
+*
+* - `attempt` is `0` for the first connect and grows by one for each reconnect.
+* - Pass `signal` into token refreshes and other async work so cancelling the session stops them.
+* - If the hook throws, the attempt fails with an `EXT_HOOK_FAILED` fault.
+* - A `beforeConnect` in the request options replaces this one for that call.
+*
+* @param beforeConnect - Hook receiving attempt index and abort signal.
+* @returns An option that sets `config.webSocket.beforeConnect`.
+* @group client
+*/
+function withWebSocketBeforeConnect(beforeConnect) {
+	return (config) => {
+		config.webSocket.beforeConnect = beforeConnect;
+	};
 }
 /**
-* Deep-merge two intersection outputs.
+* Sets the WebSocket subprotocols offered during the handshake.
 *
-* `Object.is` keeps NaN and distinguishes signed zeroes. Equal-time Dates are one instant even
-* though the instances differ. Plain objects are copied onto a null prototype so `__proto__` stays
-* an own data key. Anything else, including arrays of different lengths, is a conflict.
+* They are passed as the second argument to the `WebSocket` constructor only when the list is not empty, so the platform can run the RFC 6455 subprotocol negotiation. They matter only when the server requires a specific subprotocol, for example `['json']` or `['v1']`.
 *
-* `tagNodes` folds each side's parse tag into the new object at this level. One-sided children are
-* copied with the tag their own parser already wrote, so a later walk is not required. Null and
-* undefined never enter this branch. `depth` is the caller's logical path length, not a fresh merge budget.
-* Distinct containers consume a level even when they came from opaque leaves; identical references do not recurse.
+* Precedence, highest first: the `protocols` request option, this client option, then `protocols` on the endpoint definition.
+*
+* @param protocols - Subprotocol list for the WebSocket constructor.
+* @returns An option that sets `config.webSocket.protocols`.
+* @group client
 */
-function mergeIntersectionValues(left, right, tagNodes, depth, context) {
-	if (Object.is(left, right)) return {
-		ok: true,
-		value: left
+function withWebSocketProtocols(protocols) {
+	return (config) => {
+		config.webSocket.protocols = protocols;
 	};
-	if (left instanceof Date && right instanceof Date && left.getTime() === right.getTime()) return {
-		ok: true,
-		value: left
+}
+/**
+* Enables WebSocket heartbeat messages with optional acknowledgement detection.
+*
+* Passing `undefined` clears an earlier setting. The option type is:
+*
+* ```ts
+* {
+*   intervalMs: number
+*   isAck?: (message: unknown) => boolean
+*   message?: <T = unknown>() => T | unknown
+*   timeoutMs?: number
+* }
+* ```
+*
+* - Every `intervalMs`, `message()` is called and its result is sent through the endpoint's `outgoing` struct. No message is sent when `message` is omitted or returns `undefined`.
+* - With `timeoutMs`, an acknowledgement is expected after each heartbeat. `isAck` receives the decoded incoming message; when it returns `true`, the timer is cleared and that message is **not** delivered to `receive`.
+* - If no ack arrives within `timeoutMs`, or a heartbeat cannot be sent, the session fails. This does not trigger a reconnect.
+* - Heartbeat uses the same JSON guard as `session.send`: a value JSON cannot represent after struct encoding causes `TypeError` and ends the logical session.
+* - `intervalMs` and `timeoutMs` must be positive, finite, and at most `2_147_483_647`; otherwise the operation fails with `REQ_OPTIONS_INVALID`.
+* - A `heartbeat` in the request options replaces this one for that call.
+*
+* @param options - Heartbeat interval, payload, timeout, and ACK predicate.
+* @returns An option that sets `config.webSocket.heartbeat`.
+* @group client
+*/
+function withWebSocketHeartbeat(options) {
+	return (config) => {
+		config.webSocket.heartbeat = options;
 	};
-	if (isPlainObject(left) && isPlainObject(right)) {
-		if (depth >= 256) return {
-			ok: false,
-			path: [],
-			received: right
-		};
-		const output = nullObject();
-		for (const key of Object.keys(left)) output[key] = left[key];
-		for (const key of Object.keys(right)) {
-			if (!hasOwnKey(output, key)) {
-				output[key] = right[key];
-				continue;
+}
+/**
+* Configures automatic reconnection when the socket closes for any reason other than a manual `session.close()`.
+*
+* Reconnection is opt-in: without this option a close ends the session. Passing `undefined` clears an earlier setting. The option type is:
+*
+* ```ts
+* {
+*   attempts?: number
+*   delayMs?: number
+*   factor?: number
+*   jitter?: number
+*   maxDelayMs?: number
+*   shouldReconnect?: (context: { attempt: number; cause?: unknown; code?: number; reason?: string; wasClean?: boolean }) => boolean
+* }
+* ```
+*
+* - `attempts` is the retry budget for each outage. It defaults to `3`, and `0` disables reconnection. Successful `open` resets the budget and backoff exponent; the next outage starts at retry 1. Omitting it does not give unlimited retries within one outage. A socket that successfully opens and is immediately closed again by the server can keep reconnecting at the base delay (subject to jitter and caps), because every open resets the budget; use `shouldReconnect` to stop it.
+* - `delayMs` defaults to `1000`, `factor` to `2`, `maxDelayMs` to `30000`, and `jitter` (0 to 1) to `0`. Retry _n_ starts with `delayMs * factor^(n-1)`, capped at `maxDelayMs`; jitter and rounding follow, then the final delay is capped again at `maxDelayMs` and `2_147_483_647` ms. A zero base stays zero; valid-number overflow saturates at those caps.
+* - `shouldReconnect` can return `false` to end the session instead. Without it every close is retried while the budget lasts. It is not called for a manual `session.close()`.
+* - Reconnect options are validated before connecting: `attempts` must be a non-negative safe integer; `delayMs` must be finite and non-negative; `maxDelayMs` must be a non-negative finite number or positive `Infinity`, which removes the configured cap but not the platform limit of `2_147_483_647` ms; `factor` must be finite and positive; `jitter` must be finite and within 0–1. Invalid values make the operation fail with `REQ_OPTIONS_INVALID` before connecting. `attempts: 0` disables subsequent retries, but all explicitly supplied reconnect fields are still validated before the initial connection.
+* - A `reconnect` in the request options replaces this one for that call.
+*
+* @param options - Retry budget, backoff, and `shouldReconnect` gate.
+* @returns An option that sets `config.webSocket.reconnect`.
+* @group client
+*/
+function withWebSocketReconnect(options) {
+	return (config) => {
+		config.webSocket.reconnect = options;
+	};
+}
+/**
+* Observes SSE events that have no matching event struct or fail validation.
+*
+* The handler may be async and is awaited. The callback receives:
+*
+* ```ts
+* {
+*   reason: 'missing-struct' | 'validation-failed'
+*   message: { id: string; event: string; data: string }
+*   cause?: unknown
+*   signal: AbortSignal
+* }
+* ```
+*
+* - The invalid event is **always dropped**; it is never delivered to the stream. The callback only observes it.
+* - The return value is ignored. An error thrown by the callback is swallowed and does not close the stream, unless `signal` has already aborted.
+* - `cause` is set for `validation-failed`. Without a handler the invalid event is dropped silently.
+*
+* @param handler - Observer callback for invalid events.
+* @returns An option that sets `config.sse.onInvalidEvent`.
+* @group client
+*/
+function withSSEOnInvalidEvent(handler) {
+	return (config) => {
+		config.sse.onInvalidEvent = handler;
+	};
+}
+/**
+* Configures automatic reconnection after an SSE stream fails.
+*
+* Reconnection is opt-in: without this option a failed stream is not retried. Passing `undefined` clears an earlier setting.
+*
+* ```ts
+* type SSEReconnect = {
+*   attempts?: number;
+*   delayMs?: number;
+*   factor?: number;
+*   jitter?: number;
+*   maxDelayMs?: number;
+*   shouldReconnect?: (context: {
+*     attempt: number;
+*     cause?: unknown;
+*     lastEventId: string;
+*     method: string;
+*     open?: {
+*       response: { status: number; statusText: string; url: string };
+*       url: string;
+*     };
+*   }) => boolean | Promise<boolean>;
+* };
+* ```
+*
+* - `attempts` is the retry budget for each outage. It defaults to `3` when `reconnect` is set, and `0` disables retries. A successful handshake resets the budget, callback `attempt`, and backoff exponent. Omitting it does not give unlimited retries within one outage. Repeated successful opens followed immediately by retryable stream failures can keep reconnecting at the current base delay (subject to jitter and caps), because each open resets the budget; use `shouldReconnect` to stop them. Normal EOF remains terminal.
+* - Without `shouldReconnect`, only `GET`, `HEAD`, `OPTIONS`, `PUT`, and `DELETE` reconnect. With it, its result decides for every method, `POST` included; `method` in the context tells endpoints apart. Return `false` to stop for this failure. It runs before the attempts limit is checked.
+* - A request with a `ReadableStream` body never reconnects, and `shouldReconnect` is not called for it.
+* - `delayMs`, `factor`, `jitter` (0 to 1), and `maxDelayMs` shape the backoff. `factor` defaults to `1` and `jitter` to `0`. `maxDelayMs` caps the final delay after jitter and rounding. Without a configured cap, the platform timer limit of `2_147_483_647` ms still applies. A zero base stays zero; valid-number overflow saturates at the caps.
+* - `delayMs` is only the starting base delay (`1000` by default). A server `retry:` field (digits only, in milliseconds) replaces it for later attempts.
+* - The last event id is sent again as UTF-8 bytes in `Last-Event-ID` on the next attempt. An empty `id:` clears it; an ID containing NUL is ignored.
+* - Reconnect options are validated before interceptors or Fetch: `attempts` must be a non-negative safe integer; `delayMs` must be finite and non-negative; `maxDelayMs` must be a non-negative finite number or positive `Infinity`, which removes the configured cap but not the platform limit of `2_147_483_647` ms; `factor` must be finite and positive; `jitter` must be finite and within 0–1. Invalid values return `REQ_OPTIONS_INVALID` when the operation runs.
+*
+* @param options - Retry budget, backoff, and `shouldReconnect` gate.
+* @returns An option that sets `config.sse.reconnect`.
+* @group client
+*/
+function withSSEReconnect(options) {
+	return (config) => {
+		config.sse.reconnect = options;
+	};
+}
+/**
+* Enables XSRF cookie-to-header token forwarding for HTTP requests.
+*
+* SSE and WebSocket requests do not get the header. `cookieName` defaults to `XSRF-TOKEN` and `headerName` to `X-XSRF-TOKEN` when names are omitted.
+*
+* - The header is set only when all of these hold: the method is not `GET`, `HEAD`, `OPTIONS`, or `TRACE`; the request does not already have that header; the client has an endpoint; and, whenever `location` exists (Window or Worker), the resolved request URL has the same origin as `location.origin`. A cross-origin request does not call the provider.
+* - Without `tokenProvider`, the token is read from `document.cookie` and URL-decoded only when `document` exists. Workers and servers need a provider to supply a token.
+* - With `tokenProvider`, the cookie is never read. The provider receives the request, and its result is the token. An empty string, `null`, or `undefined` means no header.
+*
+* @param options - Cookie/header names and optional token provider.
+* @returns An option that sets `config.xsrf`.
+* @group client
+*/
+function withXSRF(options = {}) {
+	return (config) => {
+		config.xsrf = {
+			cookieName: options.cookieName ?? "XSRF-TOKEN",
+			headerName: options.headerName ?? "X-XSRF-TOKEN",
+			tokenProvider: options.tokenProvider
+		};
+	};
+}
+/**
+* Sets whether HTTP and SSE requests include credentials.
+*
+* When `value` is `true`, Fetch uses `credentials: 'include'`, so cookies and other credentials are sent with cross-origin requests. When it is `false` or never set, `credentials` is left unset and Fetch uses its default. The WebSocket constructor does not receive this setting.
+*
+* @param value - When `true`, credentials are sent with cross-origin requests.
+* @returns An option that sets `config.withCredentials`.
+* @group client
+*/
+function withCredentials(value) {
+	return (config) => {
+		config.withCredentials = value;
+	};
+}
+// src/struct/symbols.ts
+const DEFINITION = Symbol.for("defjs.struct.definition");
+const OMIT = Symbol("defjs.struct.omit");
+/**
+* Stands in for a parsed value when parsing fails; the issue waits in the slot that `failure()` fills.
+* Not in the symbol registry, so no input value can ever equal it.
+*/
+const FAILED = Symbol("defjs.struct.failed");
+/**
+* Type-only export of the internal enumerable tag key on objects produced while parsing endpoint input, used by the outbound encoder.
+*
+* `STRUCT` is exported as a **type** only (`export type { STRUCT }`). `@defjs/core` has no runtime `STRUCT` export, so `import { STRUCT } from '@defjs/core'` fails to compile and gives no value.
+*
+* It marks those objects so the outbound encoder knows which struct produced them. Response decoding and `struct.parse` leave it unset. The symbol is internal to the outbound encoder; application code should not depend on it.
+*
+* @internal
+* @group struct
+*/
+const STRUCT = Symbol.for("defjs.struct.STRUCT");
+// src/struct/guards.ts
+const KNOWN_KINDS = /* @__PURE__ */ new Set([
+	"any",
+	"array",
+	"arrayBuffer",
+	"bigint",
+	"blob",
+	"boolean",
+	"date",
+	"discriminatedUnion",
+	"enum",
+	"file",
+	"intersection",
+	"literal",
+	"null",
+	"number",
+	"object",
+	"or",
+	"record",
+	"string",
+	"tuple",
+	"unknown"
+]);
+function isStruct(value) {
+	if (typeof value !== "object" || value === null || !Object.hasOwn(value, DEFINITION)) return false;
+	const definition = value[DEFINITION];
+	if (typeof definition !== "object" || definition === null) return false;
+	if (!KNOWN_KINDS.has(definition.kind)) return false;
+	const flags = definition.flags;
+	return typeof flags === "object" && flags !== null && typeof flags.nullable === "boolean" && typeof flags.optional === "boolean";
+}
+// src/struct/guide.ts
+const GUIDE_SET = Symbol.for("defjs.struct.guideSet");
+function isGuideSet(value) {
+	return typeof value === "object" && value !== null && value[GUIDE_SET] === true;
+}
+function guideTag(members) {
+	const unique = [];
+	for (const member of members) if (!unique.includes(member)) unique.push(member);
+	if (unique.length === 0) return;
+	if (unique.length === 1) return unique[0];
+	return {
+		[GUIDE_SET]: true,
+		members: unique
+	};
+}
+function guideMembers(guide) {
+	return isGuideSet(guide) ? guide.members : [guide];
+}
+function combineGuides(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return guideTag([...guideMembers(left), ...guideMembers(right)]);
+}
+function readOwnGuide(value, guides) {
+	const tag = guides?.get(value) ?? value[STRUCT];
+	if (isGuideSet(tag)) return tag;
+	if (!isStruct(tag)) return;
+	const kind = tag[DEFINITION].kind;
+	if (kind === "object" || kind === "record") return tag;
+}
+/** Tag a null-prototype node this parse just created. Enumerable so object spread keeps its guide. */
+function tagOwnNode(value, tag) {
+	value[STRUCT] = tag;
+}
+/**
+* Deep-merge two intersection outputs.
+*
+* `Object.is` keeps NaN and distinguishes signed zeroes. Equal-time Dates are one instant even
+* though the instances differ. Plain objects are copied onto a null prototype so `__proto__` stays
+* an own data key. Anything else, including arrays of different lengths, is a conflict.
+*
+* `tagNodes` folds each side's parse tag into the new object at this level. One-sided children are
+* copied with the tag their own parser already wrote, so a later walk is not required. Null and
+* undefined never enter this branch. `depth` is the caller's logical path length, not a fresh merge budget.
+* Distinct containers consume a level even when they came from opaque leaves; identical references do not recurse.
+*/
+function mergeIntersectionValues(left, right, tagNodes, depth, context) {
+	if (Object.is(left, right)) return {
+		ok: true,
+		value: left
+	};
+	if (left instanceof Date && right instanceof Date && left.getTime() === right.getTime()) return {
+		ok: true,
+		value: left
+	};
+	if (isPlainObject(left) && isPlainObject(right)) {
+		if (depth >= 256) return {
+			ok: false,
+			path: [],
+			received: right
+		};
+		const output = nullObject();
+		for (const key of Object.keys(left)) output[key] = left[key];
+		for (const key of Object.keys(right)) {
+			if (!hasOwnKey(output, key)) {
+				output[key] = right[key];
+				continue;
 			}
 			const merged = mergeIntersectionValues(output[key], right[key], tagNodes, depth + 1, context);
 			if (!merged.ok) return {
@@ -452,7 +781,7 @@ function appendRecordToHeaders(headers, value) {
 /**
 * Resolves a relative definition path under the base endpoint's origin and directory into a URL.
 *
-* During `client.execute`, a missing, relative, or invalid base or an illegal
+* During an operation, a missing, relative, or invalid base or an illegal
 * path becomes `REQ_BUILD_FAILED` before any interceptor or transport runs,
 * including a short-circuiting interceptor, for HTTP, SSE, and WebSocket alike.
 * An interceptor's final `req.endpoint` is also validated against its final
@@ -774,527 +1103,32 @@ function createPreflightFault(code, cause, response) {
 /**
 * Builds a `NET_*` `PreflightFault`, choosing the code from the shape of `cause`.
 *
-* Optional `response` metadata is attached when the transport already had some
-* to report. The cause is kept as `cause`.
-*
-* - `NET_ABORTED` when {@link isAbortCause} recognizes an abort-branded `Error`
-*   (including `ERR_ABORTED` from another Core copy) or a `DOMException` named
-*   `AbortError`. The message is `Request was aborted`.
-* - `NET_TIMEOUT` when {@link isTimeoutCause} recognizes a timeout-branded
-*   `Error` (including `ERR_TIMEOUT` from another Core copy) or a `DOMException`
-*   or `Error` named `TimeoutError`. The message is the cause's message, or
-*   `Request timed out` when that is empty.
-* - `NET_UNREACHABLE` for anything else, with the cause's message.
-*
-* @param cause - Underlying cancellation, timeout, or transport failure.
-* @param response - Metadata, only where the transport already had some to report.
-* @returns A `NET_ABORTED`, `NET_TIMEOUT`, or `NET_UNREACHABLE` fault.
-* @group errors
-*/
-function createNetworkFault(cause, response) {
-	if (isAbortCause(cause)) return withResponse(createFault(ERR_ABORTED.message, cause), "NET_ABORTED", response);
-	if (isTimeoutCause(cause)) return withResponse(createFault(cause instanceof Error && cause.message ? cause.message : ERR_TIMEOUT.message, cause), "NET_TIMEOUT", response);
-	return withResponse(createFault(describeCause(cause), cause), "NET_UNREACHABLE", response);
-}
-function withResponse(fault, code, response) {
-	fault.code = code;
-	if (response !== void 0) fault.response = response;
-	return fault;
-}
-// src/internal/abort.ts
-const ABORT_TIMEOUT_CONFLICT_MESSAGE = "abort and timeout cannot be used together";
-const MAX_TIMER_DELAY_MS$2 = 2147483647;
-function snapshotCancellationConfig(config) {
-	return {
-		abort: config.abort,
-		signal: config.signal,
-		timeout: config.timeout
-	};
-}
-function hasAbortTimeoutConflict(config) {
-	return config !== void 0 && config.abort !== void 0 && config.timeout !== void 0;
-}
-/** The cancellation cause for an already-aborted signal, or `undefined` while it is still live. */
-function resolveAbortCause(signal) {
-	if (!signal.aborted) return;
-	return resolveAbortedCause(signal);
-}
-/** `ERR_TIMEOUT` or `ERR_ABORTED`, chosen from the signal's abort reason, including another copy's timeout sentinel. */
-function resolveAbortedCause(signal) {
-	return isTimeoutCause(signal.reason) ? ERR_TIMEOUT : ERR_ABORTED;
-}
-/** `REQ_OPTIONS_INVALID` for execute options that pass both `abort` and `timeout`. */
-function createAbortTimeoutConflictFault() {
-	return createPreflightFault("REQ_OPTIONS_INVALID", /* @__PURE__ */ new Error(ABORT_TIMEOUT_CONFLICT_MESSAGE));
-}
-/** The cancellation fault for an already-aborted signal, or `undefined` while it is still live. */
-function resolveAbortFault(signal) {
-	if (!signal.aborted) return;
-	return resolveAbortedFault(signal);
-}
-/** `NET_ABORTED` or `NET_TIMEOUT`, chosen from the signal's abort reason. */
-function resolveAbortedFault(signal) {
-	return createNetworkFault(resolveAbortedCause(signal));
-}
-function validateTransportTimeout(timeout) {
-	if (typeof timeout !== "undefined" && (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > MAX_TIMER_DELAY_MS$2)) throw new RangeError(`Request timeout must be a positive safe integer no greater than ${MAX_TIMER_DELAY_MS$2}`);
-}
-async function awaitWithSignal(run, signal) {
-	signal.throwIfAborted();
-	let rejectAbort;
-	const aborted = new Promise((_resolve, reject) => {
-		rejectAbort = reject;
-	});
-	const onAbort = () => rejectAbort(signal.reason);
-	signal.addEventListener("abort", onAbort, { once: true });
-	const task = Promise.resolve().then(() => {
-		signal.throwIfAborted();
-		return run();
-	});
-	task.catch(() => void 0);
-	try {
-		const value = await Promise.race([task, aborted]);
-		signal.throwIfAborted();
-		return value;
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
-/**
-* Arm `timeout` before synchronous parse and builder work.
-*
-* A timer task cannot run until that work yields. `expiredFault` also watches
-* the wall clock so a microtask transport cannot succeed after the deadline.
-* `release` clears the timer and makes a later wall-clock check a no-op, so a
-* settled startup can no longer abort the request signal.
-*/
-function armTransportDeadline(timeout) {
-	if (typeof timeout !== "number") return {
-		expiredFault: () => void 0,
-		release: () => void 0,
-		releaseOnAbort: () => void 0,
-		signal: void 0
-	};
-	const startedAt = Date.now();
-	const controller = new AbortController();
-	let released = false;
-	let watched;
-	const timer = setTimeout(() => {
-		controller.abort(ERR_TIMEOUT);
-	}, timeout);
-	const release = () => {
-		if (released) return;
-		released = true;
-		clearTimeout(timer);
-		watched?.removeEventListener("abort", release);
-	};
-	return {
-		release,
-		releaseOnAbort(signal) {
-			watched = signal;
-			signal.addEventListener("abort", release, { once: true });
-		},
-		signal: controller.signal,
-		expiredFault() {
-			if (released || Date.now() - startedAt < timeout) return;
-			controller.abort(ERR_TIMEOUT);
-			return resolveAbortedFault(controller.signal);
-		}
-	};
-}
-function resolveTransportCancellation(deadline, signal, fallback) {
-	return resolveAbortFault(signal) ?? deadline.expiredFault() ?? fallback;
-}
-const forwardingSignals = /* @__PURE__ */ new WeakMap();
-/** Release listeners owned by a signal returned from `mergeAbortSignals`. */
-function releaseAbortSignal(signal) {
-	forwardingSignals.get(signal)?.release();
-}
-function mergeAbortSignals(controller, signals, timeout) {
-	validateTransportTimeout(timeout);
-	const hasTimeout = typeof timeout === "number";
-	if (!hasTimeout && signals.length > 0 && signals.every((signal) => signal === void 0 || signal === controller)) return controller;
-	const merged = [];
-	const seen = /* @__PURE__ */ new Set();
-	const append = (signal) => {
-		const state = forwardingSignals.get(signal);
-		if (state?.active) {
-			for (const source of state.sources) append(source);
-			return;
-		}
-		if (!seen.has(signal)) {
-			seen.add(signal);
-			merged.push(signal);
-		}
-	};
-	append(controller);
-	for (const signal of signals) if (signal) append(signal);
-	if (!hasTimeout && merged.length === 1) return merged[0];
-	let timeoutTimer;
-	const combinedController = new AbortController();
-	const listeners = [];
-	let abortWithReason;
-	const state = {
-		active: true,
-		release() {
-			if (!state.active) return;
-			state.active = false;
-			for (const [source, listener] of listeners) source.removeEventListener("abort", listener);
-			if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
-		},
-		sources: merged
-	};
-	forwardingSignals.set(combinedController.signal, state);
-	abortWithReason = (reason) => {
-		if (combinedController.signal.aborted) return;
-		combinedController.abort(reason);
-		state.release();
-	};
-	if (hasTimeout) timeoutTimer = setTimeout(() => {
-		abortWithReason(ERR_TIMEOUT);
-	}, timeout);
-	const alreadyAborted = merged.find((signal) => signal.aborted);
-	if (alreadyAborted) {
-		abortWithReason(alreadyAborted.reason);
-		return combinedController.signal;
-	}
-	for (const source of merged) {
-		const listener = () => abortWithReason(source.reason);
-		listeners.push([source, listener]);
-		source.addEventListener("abort", listener, { once: true });
-	}
-	return combinedController.signal;
-}
-// src/client/option.ts
-/**
-* Sets the valid absolute base URL prepended to relative request paths.
-*
-* The default is an empty string, so execution requires an explicit endpoint. Its pathname is kept as a directory; its query and hash are discarded. For WebSocket commands, an `http:` base becomes `ws:` and `https:` becomes `wss:`.
-*
-* A missing, relative, or invalid endpoint, or an illegal request path, fails with `REQ_BUILD_FAILED` during building, before any interceptor or transport runs, even when an interceptor would short-circuit. HTTP, SSE, and WebSocket share this rule. The resolved request must keep the base origin and stay under its directory; C0 control characters (including tab, CR, and LF), backslashes, `?`, `#`, and directory escapes in a path are rejected. Scheme-like and protocol-relative forms are rejected even with leading spaces; a plain inner space is allowed and sent as `%20`. An interceptor's final `req.endpoint` is checked against its final `req.baseEndpoint` with the same rule, but it may deliberately replace the base with another valid absolute URL. Deterministic URL errors are never retried.
-*
-* @param endpoint - Absolute base endpoint. Missing or invalid endpoints fail request building.
-* @returns An option that writes `config.endpoint`.
-* @group client
-*/
-function withEndpoint(endpoint) {
-	return (config) => {
-		config.endpoint = endpoint;
-	};
-}
-/**
-* Sets static default headers for HTTP and SSE requests built by this client.
-*
-* WebSocket connections do not use them. The `HeadersInit` is copied into a `Headers` object when the option is applied. A later call replaces the earlier headers instead of merging.
-*
-* Headers returned by a request builder replace a default of the same name. The first value for that name replaces the default; later values in the same array append only to that replacement. A scalar or a `Headers` instance also replaces. Other default names stay.
-*
-* Per-request or computed credentials, such as a refreshed Bearer token or an HMAC signature, belong in an interceptor, because they need the serialized body or a refreshed credential.
-*
-* @param headers - `HeadersInit` bag cloned onto the client config.
-* @returns An option that writes `config.headers`.
-* @group client
-*/
-function withHeaders(headers) {
-	return (config) => {
-		config.headers = new Headers(headers);
-	};
-}
-/**
-* Sets the default timeout, in milliseconds, for HTTP `execute` only.
-*
-* SSE and WebSocket ignore it. `ms` must be a positive safe integer no greater than `2_147_483_647`. Anything else throws `RangeError` immediately, when `withTimeout` is called, not when the client executes.
-*
-* The timer starts before the interceptor chain runs. When it fires, the call returns a `NET_TIMEOUT` fault. Execute `{ timeout }` replaces this default for that call. Execute `{ abort }` combines with the default: an abort gives `NET_ABORTED`, the timer gives `NET_TIMEOUT`. Passing both `abort` and `timeout` to the same `execute` call is still rejected.
-*
-* @param ms - Positive safe integer timeout in milliseconds.
-* @returns An option that writes `config.timeout`.
-* @group client
-*/
-function withTimeout(ms) {
-	validateTransportTimeout(ms);
-	return (config) => {
-		config.timeout = ms;
-	};
-}
-/**
-* Appends interceptors to the client interceptor chain.
-*
-* Calling it again appends more; it never replaces earlier ones. The first registered interceptor is the outermost layer. HTTP, SSE, and WebSocket interceptors can be mixed in one call. At execute time only the interceptors of the command's transport run, in their registration order.
-*
-* @param interceptors - Interceptors applied in registration order.
-* @returns An option that pushes onto `config.interceptors`.
-* @group client
-*/
-function withInterceptors(...interceptors) {
-	return (config) => {
-		config.interceptors.push(...interceptors);
-	};
-}
-/**
-* Replaces query encoding for HTTP, SSE, and WebSocket requests.
-*
-* `serializer(query)` receives the encoded wire object: aliases applied, `Date` as an ISO string, `bigint` as a string. Nested objects and arrays are kept as they are. It must return the query string without a leading `?`. The string is used verbatim.
-*
-* It is not called when the request has no query. A builder that returns `URLSearchParams` skips it. Without this option, queries use `URLSearchParams`: arrays repeat keys and a nested object fails.
-*
-* @param serializer - Function that turns an encoded query object into a string.
-* @returns An option that sets `config.querySerializer`.
-* @group client
-*/
-function withQuerySerializer(serializer) {
-	return (config) => {
-		config.querySerializer = serializer;
-	};
-}
-/**
-* Replaces the Fetch-compatible function used for HTTP requests.
-*
-* The default is the platform `fetch`. `fetchImpl` is a {@link FetchHandle}, so a test double does not need host extras such as `fetch.preconnect`. It only affects HTTP. SSE uses {@link withSSEHandle}.
-*
-* @param fetchImpl - `(input, init?) => Promise<Response>`. Not `typeof fetch`, so
-*   a mock does not need host extras such as `preconnect`.
-* @returns An option that sets `config.http.handle`.
-* @group client
-*/
-function withHTTPHandle(fetchImpl) {
-	return (config) => {
-		config.http.handle = fetchImpl;
-	};
-}
-/**
-* Replaces the Fetch-compatible function used to open SSE event streams.
-*
-* The default is the platform `fetch`. `fetchImpl` is a {@link FetchHandle}. It only affects SSE. HTTP uses {@link withHTTPHandle}.
-*
-* @param fetchImpl - `(input, init?) => Promise<Response>`. Not `typeof fetch`, so
-*   a mock does not need host extras such as `preconnect`.
-* @returns An option that sets `config.sse.handle`.
-* @group client
-*/
-function withSSEHandle(fetchImpl) {
-	return (config) => {
-		config.sse.handle = fetchImpl;
-	};
-}
-/**
-* Replaces the WebSocket constructor used for socket connections.
-*
-* The default is `globalThis.WebSocket`. `WebSocketImpl` is a {@link WebSocketHandleConstructor} that returns a {@link WebSocketHandle}. If no constructor is available, executing a WebSocket command fails with an `ENV_UNSUPPORTED` fault.
-*
-* @param WebSocketImpl - Constructor that returns a `WebSocketHandle`.
-* @returns An option that sets `config.webSocket.handle`.
-* @group client
-*/
-function withWebSocketHandle(WebSocketImpl) {
-	return (config) => {
-		config.webSocket.handle = WebSocketImpl;
-	};
-}
-/**
-* Runs a hook before the initial WebSocket connect and before every reconnect.
-*
-* The hook type is:
-*
-* ```ts
-* (context: { attempt: number; signal: AbortSignal }) => void | Promise<void>
-* ```
-*
-* - `attempt` is `0` for the first connect and grows by one for each reconnect.
-* - Pass `signal` into token refreshes and other async work so cancelling the session stops them.
-* - If the hook throws, the attempt fails with an `EXT_HOOK_FAILED` fault.
-* - A `beforeConnect` in the execute options replaces this one for that call.
-*
-* @param beforeConnect - Hook receiving attempt index and abort signal.
-* @returns An option that sets `config.webSocket.beforeConnect`.
-* @group client
-*/
-function withWebSocketBeforeConnect(beforeConnect) {
-	return (config) => {
-		config.webSocket.beforeConnect = beforeConnect;
-	};
-}
-/**
-* Sets the WebSocket subprotocols offered during the handshake.
-*
-* They are passed as the second argument to the `WebSocket` constructor only when the list is not empty, so the platform can run the RFC 6455 subprotocol negotiation. They matter only when the server requires a specific subprotocol, for example `['json']` or `['v1']`.
-*
-* Precedence, highest first: the `protocols` execute option, this client option, then `protocols` on the endpoint definition.
-*
-* @param protocols - Subprotocol list for the WebSocket constructor.
-* @returns An option that sets `config.webSocket.protocols`.
-* @group client
-*/
-function withWebSocketProtocols(protocols) {
-	return (config) => {
-		config.webSocket.protocols = protocols;
-	};
-}
-/**
-* Enables WebSocket heartbeat messages with optional acknowledgement detection.
-*
-* Passing `undefined` clears an earlier setting. The option type is:
-*
-* ```ts
-* {
-*   intervalMs: number
-*   isAck?: (message: unknown) => boolean
-*   message?: <T = unknown>() => T | unknown
-*   timeoutMs?: number
-* }
-* ```
-*
-* - Every `intervalMs`, `message()` is called and its result is sent through the endpoint's `outgoing` struct. No message is sent when `message` is omitted or returns `undefined`.
-* - With `timeoutMs`, an acknowledgement is expected after each heartbeat. `isAck` receives the decoded incoming message; when it returns `true`, the timer is cleared and that message is **not** delivered to `receive`.
-* - If no ack arrives within `timeoutMs`, or a heartbeat cannot be sent, the session fails. This does not trigger a reconnect.
-* - Heartbeat uses the same JSON guard as `session.send`: a value JSON cannot represent after struct encoding causes `TypeError` and ends the logical session.
-* - `intervalMs` and `timeoutMs` must be positive, finite, and at most `2_147_483_647`; otherwise execute fails with `REQ_OPTIONS_INVALID`.
-* - A `heartbeat` in the execute options replaces this one for that call.
-*
-* @param options - Heartbeat interval, payload, timeout, and ACK predicate.
-* @returns An option that sets `config.webSocket.heartbeat`.
-* @group client
-*/
-function withWebSocketHeartbeat(options) {
-	return (config) => {
-		config.webSocket.heartbeat = options;
-	};
-}
-/**
-* Configures automatic reconnection when the socket closes for any reason other than a manual `session.close()`.
-*
-* Reconnection is opt-in: without this option a close ends the session. Passing `undefined` clears an earlier setting. The option type is:
-*
-* ```ts
-* {
-*   attempts?: number
-*   delayMs?: number
-*   factor?: number
-*   jitter?: number
-*   maxDelayMs?: number
-*   shouldReconnect?: (context: { attempt: number; cause?: unknown; code?: number; reason?: string; wasClean?: boolean }) => boolean
-* }
-* ```
-*
-* - `attempts` is the retry budget for each outage. It defaults to `3`, and `0` disables reconnection. Successful `open` resets the budget and backoff exponent; the next outage starts at retry 1. Omitting it does not give unlimited retries within one outage. A socket that successfully opens and is immediately closed again by the server can keep reconnecting at the base delay (subject to jitter and caps), because every open resets the budget; use `shouldReconnect` to stop it.
-* - `delayMs` defaults to `1000`, `factor` to `2`, `maxDelayMs` to `30000`, and `jitter` (0 to 1) to `0`. Retry _n_ starts with `delayMs * factor^(n-1)`, capped at `maxDelayMs`; jitter and rounding follow, then the final delay is capped again at `maxDelayMs` and `2_147_483_647` ms. A zero base stays zero; valid-number overflow saturates at those caps.
-* - `shouldReconnect` can return `false` to end the session instead. Without it every close is retried while the budget lasts. It is not called for a manual `session.close()`.
-* - Reconnect options are validated before connecting: `attempts` must be a non-negative safe integer; `delayMs` must be finite and non-negative; `maxDelayMs` must be a non-negative finite number or positive `Infinity`, which removes the configured cap but not the platform limit of `2_147_483_647` ms; `factor` must be finite and positive; `jitter` must be finite and within 0–1. Invalid values make execute fail with `REQ_OPTIONS_INVALID` before connecting. `attempts: 0` disables subsequent retries, but all explicitly supplied reconnect fields are still validated before the initial connection.
-* - A `reconnect` in the execute options replaces this one for that call.
-*
-* @param options - Retry budget, backoff, and `shouldReconnect` gate.
-* @returns An option that sets `config.webSocket.reconnect`.
-* @group client
-*/
-function withWebSocketReconnect(options) {
-	return (config) => {
-		config.webSocket.reconnect = options;
-	};
-}
-/**
-* Observes SSE events that have no matching event struct or fail validation.
-*
-* The handler may be async and is awaited. The callback receives:
-*
-* ```ts
-* {
-*   reason: 'missing-struct' | 'validation-failed'
-*   message: { id: string; event: string; data: string }
-*   cause?: unknown
-*   signal: AbortSignal
-* }
-* ```
-*
-* - The invalid event is **always dropped**; it is never delivered to the stream. The callback only observes it.
-* - The return value is ignored. An error thrown by the callback is swallowed and does not close the stream, unless `signal` has already aborted.
-* - `cause` is set for `validation-failed`. Without a handler the invalid event is dropped silently.
-*
-* @param handler - Observer callback for invalid events.
-* @returns An option that sets `config.sse.onInvalidEvent`.
-* @group client
-*/
-function withSSEOnInvalidEvent(handler) {
-	return (config) => {
-		config.sse.onInvalidEvent = handler;
-	};
-}
-/**
-* Configures automatic reconnection after an SSE stream fails.
-*
-* Reconnection is opt-in: without this option a failed stream is not retried. Passing `undefined` clears an earlier setting.
-*
-* ```ts
-* type SSEReconnect = {
-*   attempts?: number;
-*   delayMs?: number;
-*   factor?: number;
-*   jitter?: number;
-*   maxDelayMs?: number;
-*   shouldReconnect?: (context: {
-*     attempt: number;
-*     cause?: unknown;
-*     lastEventId: string;
-*     method: string;
-*     open?: {
-*       response: { status: number; statusText: string; url: string };
-*       url: string;
-*     };
-*   }) => boolean | Promise<boolean>;
-* };
-* ```
-*
-* - `attempts` is the retry budget for each outage. It defaults to `3` when `reconnect` is set, and `0` disables retries. A successful handshake resets the budget, callback `attempt`, and backoff exponent. Omitting it does not give unlimited retries within one outage. Repeated successful opens followed immediately by retryable stream failures can keep reconnecting at the current base delay (subject to jitter and caps), because each open resets the budget; use `shouldReconnect` to stop them. Normal EOF remains terminal.
-* - Without `shouldReconnect`, only `GET`, `HEAD`, `OPTIONS`, `PUT`, and `DELETE` reconnect. With it, its result decides for every method, `POST` included; `method` in the context tells endpoints apart. Return `false` to stop for this failure. It runs before the attempts limit is checked.
-* - A request with a `ReadableStream` body never reconnects, and `shouldReconnect` is not called for it.
-* - `delayMs`, `factor`, `jitter` (0 to 1), and `maxDelayMs` shape the backoff. `factor` defaults to `1` and `jitter` to `0`. `maxDelayMs` caps the final delay after jitter and rounding. Without a configured cap, the platform timer limit of `2_147_483_647` ms still applies. A zero base stays zero; valid-number overflow saturates at the caps.
-* - `delayMs` is only the starting base delay (`1000` by default). A server `retry:` field (digits only, in milliseconds) replaces it for later attempts.
-* - The last event id is sent again as UTF-8 bytes in `Last-Event-ID` on the next attempt. An empty `id:` clears it; an ID containing NUL is ignored.
-* - Reconnect options are validated before interceptors or Fetch: `attempts` must be a non-negative safe integer; `delayMs` must be finite and non-negative; `maxDelayMs` must be a non-negative finite number or positive `Infinity`, which removes the configured cap but not the platform limit of `2_147_483_647` ms; `factor` must be finite and positive; `jitter` must be finite and within 0–1. Invalid values return `REQ_OPTIONS_INVALID` at execute time.
-*
-* @param options - Retry budget, backoff, and `shouldReconnect` gate.
-* @returns An option that sets `config.sse.reconnect`.
-* @group client
-*/
-function withSSEReconnect(options) {
-	return (config) => {
-		config.sse.reconnect = options;
-	};
-}
-/**
-* Enables XSRF cookie-to-header token forwarding for HTTP requests.
-*
-* SSE and WebSocket requests do not get the header. `cookieName` defaults to `XSRF-TOKEN` and `headerName` to `X-XSRF-TOKEN` when names are omitted.
-*
-* - The header is set only when all of these hold: the method is not `GET`, `HEAD`, `OPTIONS`, or `TRACE`; the request does not already have that header; the client has an endpoint; and, whenever `location` exists (Window or Worker), the resolved request URL has the same origin as `location.origin`. A cross-origin request does not call the provider.
-* - Without `tokenProvider`, the token is read from `document.cookie` and URL-decoded only when `document` exists. Workers and servers need a provider to supply a token.
-* - With `tokenProvider`, the cookie is never read. The provider receives the request, and its result is the token. An empty string, `null`, or `undefined` means no header.
-*
-* @param options - Cookie/header names and optional token provider.
-* @returns An option that sets `config.xsrf`.
-* @group client
-*/
-function withXSRF(options = {}) {
-	return (config) => {
-		config.xsrf = {
-			cookieName: options.cookieName ?? "XSRF-TOKEN",
-			headerName: options.headerName ?? "X-XSRF-TOKEN",
-			tokenProvider: options.tokenProvider
-		};
-	};
-}
-/**
-* Sets whether HTTP and SSE requests include credentials.
-*
-* When `value` is `true`, Fetch uses `credentials: 'include'`, so cookies and other credentials are sent with cross-origin requests. When it is `false` or never set, `credentials` is left unset and Fetch uses its default. The WebSocket constructor does not receive this setting.
+* Optional `response` metadata is attached when the transport already had some
+* to report. The cause is kept as `cause`.
 *
-* @param value - When `true`, credentials are sent with cross-origin requests.
-* @returns An option that sets `config.withCredentials`.
-* @group client
+* - `NET_ABORTED` when {@link isAbortCause} recognizes an abort-branded `Error`
+*   (including `ERR_ABORTED` from another Core copy) or a `DOMException` named
+*   `AbortError`. The message is `Request was aborted`.
+* - `NET_TIMEOUT` when {@link isTimeoutCause} recognizes a timeout-branded
+*   `Error` (including `ERR_TIMEOUT` from another Core copy) or a `DOMException`
+*   or `Error` named `TimeoutError`. The message is the cause's message, or
+*   `Request timed out` when that is empty.
+* - `NET_UNREACHABLE` for anything else, with the cause's message.
+*
+* @param cause - Underlying cancellation, timeout, or transport failure.
+* @param response - Metadata, only where the transport already had some to report.
+* @returns A `NET_ABORTED`, `NET_TIMEOUT`, or `NET_UNREACHABLE` fault.
+* @group errors
 */
-function withCredentials(value) {
-	return (config) => {
-		config.withCredentials = value;
-	};
+function createNetworkFault(cause, response) {
+	if (isAbortCause(cause)) return withResponse(createFault(ERR_ABORTED.message, cause), "NET_ABORTED", response);
+	if (isTimeoutCause(cause)) return withResponse(createFault(cause instanceof Error && cause.message ? cause.message : ERR_TIMEOUT.message, cause), "NET_TIMEOUT", response);
+	return withResponse(createFault(describeCause(cause), cause), "NET_UNREACHABLE", response);
+}
+function withResponse(fault, code, response) {
+	fault.code = code;
+	if (response !== void 0) fault.response = response;
+	return fault;
 }
 // src/interceptor/interceptor.ts
 /**
@@ -1303,10 +1137,10 @@ function withCredentials(value) {
 * Returns `{ kind: 'http', fn }`. Call `next(req)` (optionally with a modified
 * request) or short-circuit with `makeResponse`. `next` runs only the
 * interceptors registered after this one and then the fetch handler. HTTP
-* interceptors do not run for SSE or WebSocket commands.
+* interceptors do not run for SSE or WebSocket operations.
 *
 * A deterministic URL error from `next(req)` rejects the returned promise, so
-* `.then` or `.catch` recovery runs; if it is not recovered, `client.execute`
+* `.then` or `.catch` recovery runs; if it is not recovered, the operation
 * still reports `REQ_BUILD_FAILED`.
 *
 * @param fn - HTTP interceptor function.
@@ -1322,12 +1156,12 @@ function createHttpInterceptor(fn) {
 /**
 * Wraps an `SSEInterceptorFn` as a tagged `SSEInterceptor`.
 *
-* Returns `{ kind: 'sse', fn }`. SSE interceptors run only for SSE commands, in
+* Returns `{ kind: 'sse', fn }`. SSE interceptors run only for SSE operations, in
 * registration order; `next(req)` opens the stream through the remaining
 * interceptors.
 *
 * A deterministic URL error from `next(req)` rejects the returned promise, so
-* `.then` or `.catch` recovery runs; if it is not recovered, `client.execute`
+* `.then` or `.catch` recovery runs; if it is not recovered, the operation
 * still reports `REQ_BUILD_FAILED`.
 *
 * `EventStreamHandle` extends `AsyncDisposable`. A structural short-circuit
@@ -1348,7 +1182,7 @@ function createSSEInterceptor(fn) {
 * Wraps a `WebSocketInterceptorFn` as a tagged `WebSocketInterceptor`.
 *
 * Returns `{ kind: 'web-socket', fn }`. WebSocket interceptors run only for
-* WebSocket commands. `next` and the interceptor return a
+* WebSocket operations. `next` and the interceptor return a
 * {@link WebSocketSessionLike}, the interceptor-facing session. A wrapper or
 * short-circuit session must forward its `[Symbol.asyncDispose]()` teardown.
 *
@@ -1377,6 +1211,99 @@ function resolveSSEInterceptors(interceptors) {
 function resolveWebSocketInterceptors(interceptors) {
 	return interceptors.filter((i) => i.kind === "web-socket").map((i) => i.fn);
 }
+// src/internal/abort.ts
+/** The cancellation cause for an already-aborted signal, or `undefined` while it is still live. */
+function resolveAbortCause(signal) {
+	if (!signal.aborted) return;
+	return resolveAbortedCause(signal);
+}
+/** `ERR_TIMEOUT` or `ERR_ABORTED`, chosen from the signal's abort reason, including another copy's timeout sentinel. */
+function resolveAbortedCause(signal) {
+	return isTimeoutCause(signal.reason) ? ERR_TIMEOUT : ERR_ABORTED;
+}
+/** The cancellation fault for an already-aborted signal, or `undefined` while it is still live. */
+function resolveAbortFault(signal) {
+	if (!signal.aborted) return;
+	return resolveAbortedFault(signal);
+}
+/** `NET_ABORTED` or `NET_TIMEOUT`, chosen from the signal's abort reason. */
+function resolveAbortedFault(signal) {
+	return createNetworkFault(resolveAbortedCause(signal));
+}
+async function awaitWithSignal(run, signal) {
+	signal.throwIfAborted();
+	let rejectAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		rejectAbort = reject;
+	});
+	const onAbort = () => rejectAbort(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	const task = Promise.resolve().then(() => {
+		signal.throwIfAborted();
+		return run();
+	});
+	task.catch(() => void 0);
+	try {
+		const value = await Promise.race([task, aborted]);
+		signal.throwIfAborted();
+		return value;
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+const forwardingSignals = /* @__PURE__ */ new WeakMap();
+/** Release listeners owned by a signal returned from `mergeAbortSignals`. */
+function releaseAbortSignal(signal) {
+	forwardingSignals.get(signal)?.release();
+}
+function mergeAbortSignals(controller, signals) {
+	if (signals.length > 0 && signals.every((signal) => signal === void 0 || signal === controller)) return controller;
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	const append = (signal) => {
+		const state = forwardingSignals.get(signal);
+		if (state?.active) {
+			for (const source of state.sources) append(source);
+			return;
+		}
+		if (!seen.has(signal)) {
+			seen.add(signal);
+			merged.push(signal);
+		}
+	};
+	append(controller);
+	for (const signal of signals) if (signal) append(signal);
+	if (merged.length === 1) return merged[0];
+	const combinedController = new AbortController();
+	const listeners = [];
+	let abortWithReason;
+	const state = {
+		active: true,
+		release() {
+			if (!state.active) return;
+			state.active = false;
+			for (const [source, listener] of listeners) source.removeEventListener("abort", listener);
+		},
+		sources: merged
+	};
+	forwardingSignals.set(combinedController.signal, state);
+	abortWithReason = (reason) => {
+		if (combinedController.signal.aborted) return;
+		combinedController.abort(reason);
+		state.release();
+	};
+	const alreadyAborted = merged.find((signal) => signal.aborted);
+	if (alreadyAborted) {
+		abortWithReason(alreadyAborted.reason);
+		return combinedController.signal;
+	}
+	for (const source of merged) {
+		const listener = () => abortWithReason(source.reason);
+		listeners.push([source, listener]);
+		source.addEventListener("abort", listener, { once: true });
+	}
+	return combinedController.signal;
+}
 // src/internal/bytes.ts
 const textDecoder = new TextDecoder();
 function decodeBytes(value) {
@@ -1774,7 +1701,9 @@ var StructError = class extends Error {
 	}
 };
 function createFormattedError() {
-	return Object.assign(Object.create(null), { _errors: [] });
+	const node = Object.create(null);
+	node._errors = [];
+	return node;
 }
 function formatErrorTreeKey(segment) {
 	const key = String(segment);
@@ -2696,7 +2625,7 @@ function createBaseTransportRequest(method, path, input, builder, options) {
 	const declaredContentType = headers.has("content-type");
 	if (options.transport === "sse" && built.defaultContentType && !declaredContentType) headers.set("content-type", built.defaultContentType);
 	const request = {
-		abort: options.abort,
+		signal: options.signal,
 		baseEndpoint: options.baseEndpoint,
 		body: built.body,
 		bodyContentTypeSource: built.body,
@@ -2706,7 +2635,6 @@ function createBaseTransportRequest(method, path, input, builder, options) {
 		operation: options.operation,
 		queryParams,
 		queryString,
-		timeout: options.timeout,
 		withCredentials: options.withCredentials ?? false
 	};
 	resolveRequestUrl(request);
@@ -2718,14 +2646,13 @@ function createBaseTransportRequest(method, path, input, builder, options) {
 function createHttpRequest(method, path, input, builder, options) {
 	return {
 		...createBaseTransportRequest(method, path, input, builder, {
-			abort: options.abort,
+			signal: options.signal,
 			baseEndpoint: options.baseEndpoint,
 			defaultHeaders: options.defaultHeaders,
 			inputDeclared: options.inputDeclared,
 			inputGuides: options.inputGuides,
 			operation: options.operation,
 			querySerializer: options.querySerializer,
-			timeout: options.timeout,
 			transport: "http",
 			withCredentials: options.withCredentials
 		}),
@@ -2743,7 +2670,7 @@ function createHttpRequest(method, path, input, builder, options) {
 *
 * An upload observer can fail before any response exists, so `meta` is absent then. Download
 * observers, truncated reads, and representation checks already have a response. Those steps
-* are indistinguishable once they collapse into a bare cause, so command execution maps
+* are indistinguishable once they collapse into a bare cause, so operation execution maps
 * `code` straight through.
 *
 * Caller cancellation is deliberately never tagged: it stays the raw abort reason so the
@@ -3014,8 +2941,8 @@ function createFetchRequestInit(request) {
 	return createFetchInitBase(request, {
 		defaultAccept: "application/json, text/plain, */*",
 		headers,
-		signal: request.abort,
-		wrapReadableStreamBody: uploadProgress ? (body) => wrapUploadProgressStream(body, uploadProgress, getContentLength(headers), request.abort) : void 0
+		signal: request.signal,
+		wrapReadableStreamBody: uploadProgress ? (body) => wrapUploadProgressStream(body, uploadProgress, getContentLength(headers), request.signal) : void 0
 	});
 }
 function createFetchRequest(request) {
@@ -3075,7 +3002,7 @@ async function parseFetchResponse(httpRequest, response, fallbackUrl, platform)
 		throw new BodyFailure("RES_MEDIA_TYPE_INVALID", /* @__PURE__ */ new TypeError(`Expected a JSON media type, received ${contentType || "<none>"}`), meta);
 	}
 	if (response.body && platform && !downloadProgress) {
-		const bytes = await readWholeBody(response, httpRequest.abort, meta);
+		const bytes = await readWholeBody(response, httpRequest.signal, meta);
 		try {
 			body = parseBytesBody(responseType, bytes, contentType);
 		} catch (error) {
@@ -3084,7 +3011,7 @@ async function parseFetchResponse(httpRequest, response, fallbackUrl, platform)
 	} else if (response.body) {
 		const chunks = [];
 		const reader = response.body.getReader();
-		const signal = httpRequest.abort;
+		const signal = httpRequest.signal;
 		const cancelRead = () => void reader.cancel(signal?.reason).catch(() => void 0);
 		signal?.addEventListener("abort", cancelRead, { once: true });
 		let receivedLength = 0;
@@ -3140,7 +3067,7 @@ async function parseFetchResponse(httpRequest, response, fallbackUrl, platform)
 * global `fetch` resolved at send time. It rejects, rather than resolving with
 * a synthetic response, when no response reached the client.
 *
-* @param httpRequest - Normalized request (URL, headers, body, abort, progress hooks).
+* @param httpRequest - Normalized request (URL, headers, body, signal, progress hooks).
 * @param fetchImpl - Fetch implementation; defaults to global `fetch`. The library default handle is called as
 *   `(url, init)` while the global is untouched, and its body is read in one piece unless download progress is observed. Any other handle receives a
 *   `Request` and its body is read chunk by chunk.
@@ -3168,13 +3095,13 @@ async function fetchHandler(httpRequest, fetchImpl = resolveGlobalFetch()) {
 	try {
 		response = await sendFetchRequest(observed, fetchImpl);
 	} catch (error) {
-		throw observerFailure !== void 0 && !httpRequest.abort?.aborted ? observerFailure : error;
+		throw observerFailure !== void 0 && !httpRequest.signal?.aborted ? observerFailure : error;
 	}
 	if (observerFailure !== void 0) throw observerFailure;
 	return response;
 }
 async function sendFetchRequest(httpRequest, fetchImpl) {
-	const abortSignal = httpRequest.abort;
+	const abortSignal = httpRequest.signal;
 	const platform = fetchImpl === PLATFORM_FETCH_HANDLE;
 	let prepared = httpRequest;
 	let request;
@@ -3219,7 +3146,7 @@ function isBrowserWindowOrWorker() {
 async function prepareUploadProgressRequest(request) {
 	const { uploadProgress, body } = request;
 	if (!uploadProgress || body == null || isReadableStreamBody(body) || !supportsStreamingRequestBody() || isBrowserWindowOrWorker()) return request;
-	request.abort?.throwIfAborted();
+	request.signal?.throwIfAborted();
 	const converted = convertBodyToUploadStream(body);
 	if (!converted) return request;
 	const headers = new Headers(request.headers);
@@ -3233,7 +3160,7 @@ async function prepareUploadProgressRequest(request) {
 		total
 	};
 	try {
-		if (request.abort) await awaitWithSignal(() => uploadProgress(startEvent), request.abort);
+		if (request.signal) await awaitWithSignal(() => uploadProgress(startEvent), request.signal);
 		else await uploadProgress(startEvent);
 	} catch (error) {
 		converted.stream.cancel(error).catch(() => void 0);
@@ -3272,8 +3199,7 @@ function convertBodyToUploadStream(body) {
 * Declares a typed HTTP request endpoint.
 *
 * Pass method, path, an optional input struct, and the single `output` and
-* `error` structs. Call the returned endpoint with input to get an `HttpCommand`
-* for `client.execute`.
+* `error` structs. Call the returned operation with a client and, when declared, the input.
 *
 * The contract is `method`, `path`, an optional `input` struct, optional
 * `output` and `error` structs, and an optional `operation`. A declared `input`
@@ -3289,7 +3215,7 @@ function convertBodyToUploadStream(body) {
 * omitting one means that body is never read.
 *
 * @param definition - Request contract (method, path, input, builder, output).
-* @returns An endpoint that creates `HttpCommand` values from input.
+* @returns An operation `(client, ...input) => Promise<error-first tuple>`.
 *
 * The checked example file passes the whole input object as `path`. This snippet maps individual fields into `path` and `query` instead:
 *
@@ -3308,43 +3234,10 @@ function convertBodyToUploadStream(body) {
 */
 function defineRequest(definition) {
 	const endpoint = { ...definition };
-	function create(input) {
-		return {
-			[COMMAND_EXECUTE]: executeHttpCommand,
-			[COMMAND_TYPE]: HTTP_COMMAND,
-			definition: endpoint,
-			input
-		};
-	}
-	return ((input) => create(input));
+	return (async (client, input) => executeHttpCommand(client[CLIENT].config, endpoint, input, client[CLIENT].options));
 }
-/**
-* Runs an `HttpCommand` against client config: validate input, send the request, and parse the response.
-*
-* Low-level entry used by `client.execute`. Prefer `client.execute(command, options)`
-* in application code. `HttpClientConfig` is the HTTP part of `ClientConfig`, so
-* a `ClientConfig` is accepted. `HttpExecuteAwaitResult` is the internal result
-* tuple.
-*
-* The result is `[null, data, response]` or `[fault, undefined, undefined]`.
-* `data` is the decoded `output` body, or `undefined` when none is declared.
-* `response` is `DecodedResponse` when `output` is declared and `HttpMeta`
-* otherwise. The fault is `Fault<TError>`. A non-2xx status is `HTTP_STATUS`
-* when no `error` struct is declared (its `data` is `undefined`) or when the
-* declared body decodes (its `data` is that body). When a declared `error` body
-* cannot be read, the fault is a `RES_*` decode fault instead. On failure the
-* tuple's third slot is `undefined`; the fault carries the response metadata.
-* `options.timeout` falls back to the client's `withTimeout` default when omitted.
-*
-* @param clientConfig - Resolved HTTP client configuration (endpoint, interceptors, handler).
-* @param command - Command from a `defineRequest` endpoint.
-* @param options - Per-request progress and cancellation options.
-* @returns An await-result tuple of success body or typed request error.
-* @group http
-*/
-async function executeHttpCommand(clientConfig, command, options) {
-	const { definition, input } = command;
-	const config = options ?? {};
+async function executeHttpCommand(clientConfig, definition, input, options) {
+	const config = options;
 	const fail = (fault) => {
 		return [
 			fault,
@@ -3352,34 +3245,10 @@ async function executeHttpCommand(clientConfig, command, options) {
 			void 0
 		];
 	};
-	let cancellation;
-	try {
-		cancellation = snapshotCancellationConfig({
-			abort: config.abort,
-			signal: config.signal,
-			timeout: config.timeout !== void 0 ? config.timeout : clientConfig.timeout
-		});
-	} catch (error) {
-		return fail(createPreflightFault("REQ_OPTIONS_INVALID", error));
-	}
-	if (hasAbortTimeoutConflict(config)) return fail(createAbortTimeoutConflictFault());
-	try {
-		validateTransportTimeout(cancellation.timeout);
-	} catch (error) {
-		return fail(createPreflightFault("REQ_OPTIONS_INVALID", error));
-	}
-	const controller = new AbortController();
-	const preAbortedSignal = [cancellation.abort, cancellation.signal].find((signal) => signal?.aborted);
-	if (preAbortedSignal) return fail(resolveAbortedFault(preAbortedSignal));
-	const deadline = armTransportDeadline(cancellation.timeout);
-	const requestSignal = cancellation.abort === void 0 && cancellation.signal === void 0 && deadline.signal ? deadline.signal : mergeAbortSignals(controller.signal, [
-		cancellation.abort,
-		cancellation.signal,
-		deadline.signal
-	]);
-	deadline.releaseOnAbort(requestSignal);
+	const callerAbort = config.signal;
+	if (callerAbort?.aborted) return fail(resolveAbortedFault(callerAbort));
+	const requestSignal = mergeAbortSignals(new AbortController().signal, [callerAbort]);
 	const stopBeforeTransport = (fault) => {
-		deadline.release();
 		releaseAbortSignal(requestSignal);
 		return fail(fault);
 	};
@@ -3390,14 +3259,14 @@ async function executeHttpCommand(clientConfig, command, options) {
 	try {
 		parsedInput = parseEndpointInput(definition.input, input, inputGuides);
 	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, requestSignal, createPreflightFault("REQ_INPUT_INVALID", error)));
+		return stopBeforeTransport(resolveAbortFault(requestSignal) ?? createPreflightFault("REQ_INPUT_INVALID", error));
 	}
-	const parsedCancellation = resolveTransportCancellation(deadline, requestSignal);
+	const parsedCancellation = resolveAbortFault(requestSignal);
 	if (parsedCancellation) return stopBeforeTransport(parsedCancellation);
 	let request;
 	try {
 		request = createHttpRequest(definition.method, definition.path, parsedInput, definition.builder, {
-			abort: requestSignal,
+			signal: requestSignal,
 			baseEndpoint: clientConfig.endpoint,
 			defaultHeaders: clientConfig.headers,
 			downloadProgress: config.onDownloadProgress,
@@ -3407,17 +3276,15 @@ async function executeHttpCommand(clientConfig, command, options) {
 			operation: definition.operation,
 			querySerializer: clientConfig.querySerializer,
 			responseType,
-			timeout: cancellation.timeout,
 			uploadProgress: config.onUploadProgress,
 			withCredentials: clientConfig.withCredentials,
 			xsrf: clientConfig.xsrf
 		});
 	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, requestSignal, createPreflightFault("REQ_BUILD_FAILED", error)));
+		return stopBeforeTransport(resolveAbortFault(requestSignal) ?? createPreflightFault("REQ_BUILD_FAILED", error));
 	}
-	const builtCancellation = resolveTransportCancellation(deadline, requestSignal);
+	const builtCancellation = resolveAbortFault(requestSignal);
 	if (builtCancellation) return stopBeforeTransport(builtCancellation);
-	const releaseRequestTimeout = deadline.release;
 	const transportOrigin = createTransportOrigin();
 	const transportController = new AbortController();
 	let chainSettled = false;
@@ -3436,8 +3303,8 @@ async function executeHttpCommand(clientConfig, command, options) {
 			rejected.catch(() => void 0);
 			return rejected;
 		}
-		const transportAbort = nextRequest.abort === void 0 || nextRequest.abort === requestSignal ? transportController.signal : mergeAbortSignals(transportController.signal, [nextRequest.abort]);
-		if (resolveTransportCancellation(deadline, transportAbort)) {
+		const transportAbort = nextRequest.signal === void 0 || nextRequest.signal === requestSignal ? transportController.signal : mergeAbortSignals(transportController.signal, [nextRequest.signal]);
+		if (resolveAbortFault(transportAbort)) {
 			const rejected = Promise.reject(transportOrigin.mark(resolveAbortCause(transportAbort)));
 			releaseAbortSignal(transportAbort);
 			rejected.catch(() => void 0);
@@ -3445,7 +3312,7 @@ async function executeHttpCommand(clientConfig, command, options) {
 		}
 		const pending = fetchHandler({
 			...nextRequest,
-			abort: transportAbort
+			signal: transportAbort
 		}, clientConfig.http.handle).catch((error) => {
 			throw transportOrigin.mark(resolveAbortCause(transportAbort) ?? error);
 		}).finally(() => {
@@ -3469,7 +3336,7 @@ async function executeHttpCommand(clientConfig, command, options) {
 			response = settled;
 		} catch (error) {
 			const fromTransport = transportOrigin.has(error);
-			const cancelled = resolveTransportCancellation(deadline, requestSignal);
+			const cancelled = resolveAbortFault(requestSignal);
 			if (cancelled) {
 				abortTransport();
 				if (inflightTransport) await Promise.allSettled([inflightTransport]);
@@ -3486,19 +3353,13 @@ async function executeHttpCommand(clientConfig, command, options) {
 		requestSignal.removeEventListener("abort", abortTransport);
 		chainSettled = true;
 		if (!transportController.signal.aborted) transportController.abort(/* @__PURE__ */ new Error("HTTP interceptor chain settled"));
-		if (!response) {
-			releaseRequestTimeout();
-			releaseAbortSignal(requestSignal);
-		}
+		if (!response) releaseAbortSignal(requestSignal);
 	}
 	const settledResponse = response;
 	const meta = toHttpMeta(settledResponse);
 	const struct = settledResponse.ok ? definition.output : definition.error;
 	if (!struct) {
-		const cancelled = resolveTransportCancellation(deadline, requestSignal);
-		releaseRequestTimeout();
 		releaseAbortSignal(requestSignal);
-		if (cancelled) return fail(cancelled);
 		if (settledResponse.ok) return [
 			null,
 			void 0,
@@ -3509,16 +3370,13 @@ async function executeHttpCommand(clientConfig, command, options) {
 	let decoded;
 	try {
 		decoded = await decodeDeclaredBody(struct, settledResponse, requestSignal);
-		const cancelled = resolveTransportCancellation(deadline, requestSignal);
-		if (cancelled) return fail(cancelled);
 	} catch (error) {
-		const cancelled = resolveTransportCancellation(deadline, requestSignal);
+		const cancelled = resolveAbortFault(requestSignal);
 		if (cancelled) return fail(cancelled);
 		if (error instanceof JsonMediaTypeError) return fail(createDecodeFault("RES_MEDIA_TYPE_INVALID", error, meta));
 		if (error instanceof StructError) return fail(createDecodeFault("RES_STRUCT_MISMATCH", error, meta));
 		return fail(createDecodeFault("RES_DECODE_FAILED", error, meta));
 	} finally {
-		releaseRequestTimeout();
 		releaseAbortSignal(requestSignal);
 	}
 	const decodedResponse = {
@@ -3608,7 +3466,7 @@ function createBasicAuthModifier(fn, options) {
 * `encode`, calling `basicAuthHttpInterceptor` throws
 * `Error: BasicAuthInterceptor is not supported in this environment` when `btoa`
 * is not available in the runtime. Use {@link basicAuthSSEInterceptor} for SSE
-* commands.
+* operations.
 *
 * @param fn - Factory returning username/password for each request.
 * @param options - Optional custom encoder (defaults to `btoa`).
@@ -4010,7 +3868,7 @@ async function fetchEventStream(request, options) {
 	}
 	async function start() {
 		while (!closeController.signal.aborted) {
-			const attemptAbort = mergeAbortSignals(closeController.signal, [request.abort]);
+			const attemptAbort = mergeAbortSignals(closeController.signal, [request.signal]);
 			let response;
 			let readerStarted = false;
 			try {
@@ -4047,8 +3905,8 @@ async function fetchEventStream(request, options) {
 				return;
 			} catch (error) {
 				if (response?.body && !readerStarted) response.body.cancel(error).catch(() => void 0);
-				const normalizedError = normalizeAbortError(error, request.abort, closeController.signal);
-				if (closeController.signal.aborted || request.abort?.aborted) {
+				const normalizedError = normalizeAbortError(error, request.signal, closeController.signal);
+				if (closeController.signal.aborted || request.signal?.aborted) {
 					finishAborted(attemptAbort);
 					return;
 				}
@@ -4056,7 +3914,7 @@ async function fetchEventStream(request, options) {
 				const fatalError = toEventStreamFatalError(retryError);
 				if (fatalError) {
 					await observeFatalError(fatalError, attemptAbort);
-					if (closeController.signal.aborted || request.abort?.aborted) finishAborted(attemptAbort);
+					if (closeController.signal.aborted || request.signal?.aborted) finishAborted(attemptAbort);
 					else finishError(fatalError);
 					return;
 				}
@@ -4068,7 +3926,7 @@ async function fetchEventStream(request, options) {
 				try {
 					retryDelay = await resolveRetryDelay(retryError, attemptAbort);
 				} catch (policyError) {
-					if (closeController.signal.aborted || request.abort?.aborted) finishAborted(attemptAbort);
+					if (closeController.signal.aborted || request.signal?.aborted) finishAborted(attemptAbort);
 					else finishError(policyError);
 					return;
 				}
@@ -4080,7 +3938,7 @@ async function fetchEventStream(request, options) {
 					await wait(retryDelay, attemptAbort);
 				} catch (waitError) {
 					/* istanbul ignore else -- @preserve */
-					if (closeController.signal.aborted || request.abort?.aborted) finishAborted(attemptAbort);
+					if (closeController.signal.aborted || request.signal?.aborted) finishAborted(attemptAbort);
 					else finishError(waitError);
 					return;
 				}
@@ -4298,15 +4156,15 @@ function toCloseReason(reason) {
 /**
 * Declare a typed Server-Sent Events endpoint.
 *
-* Pass path, event structs, and buffer/queue limits. Call the returned endpoint
-* with input to get an `EventStreamCommand` for `client.execute`.
+* Pass path, event structs, and buffer/queue limits. Call the returned operation
+* with a client and, when declared, the input.
 *
 * - **definition** — `path`, an `events` map, and the required `maxBufferSize` and `maxQueueSize` limits (positive safe integers). Optional `method` (default `'GET'`), `operation`, `input`, and `error`. A declared `input` always requires an explicit `builder`. `input` only defines the parameters; the builder alone decides where each value goes. Only definitions without `input` may omit `builder`.
 *
 * `EventStreamDefinitionBase`, `EventStreamErrorField`, and `BuilderField` are internal helper types: `error` is required only when `TError` is a struct, and `builder` is `(input: BuilderInput<TInput>) => EventStreamRequestShape` when `input` is declared.
 *
 * @param definition - SSE contract (path, events, buffer limits, optional input).
-* @returns An endpoint that creates `EventStreamCommand` values from input.
+* @returns An operation `(client, ...input) => Promise<error-first tuple>`.
 *
 * @group sse
 * @exampleFile examples/api/define-event-stream.ts#example
@@ -4316,61 +4174,12 @@ function defineEventStream(definition) {
 		...definition,
 		method: definition.method ?? "GET"
 	};
-	function create(input) {
-		return {
-			[COMMAND_EXECUTE]: executeEventStreamCommand,
-			[COMMAND_TYPE]: EVENT_STREAM_COMMAND,
-			endpoint,
-			input
-		};
-	}
-	return ((input) => create(input));
-}
-/**
-* Open an SSE command against the given client config.
-*
-* Prefer `client.execute(command)` in application code; this is the low-level entry used by the client.
-*
-* The result is `[null, stream, open]` or `[fault, undefined, open | undefined]`. The fault is `Fault<TError>`: the decoded handshake body is on `data` when `error` is declared, and `Fault<undefined>` otherwise.
-*
-* @param clientConfig - Resolved client configuration.
-* @param command - SSE command from an `EventStreamEndpoint`.
-* @param options - Optional execute options (abort, timeout).
-* @returns Await-result tuple of `[error, stream, open]`.
-* @group sse
-*/
-async function executeEventStreamCommand(clientConfig, command, options) {
-	const { endpoint, input } = command;
-	return runEventStreamCommand(clientConfig, endpoint, input, options ?? {}, new AbortController());
+	return (async (client, input) => runEventStreamCommand(client[CLIENT].config, endpoint, input, client[CLIENT].options, new AbortController()));
 }
 async function runEventStreamCommand(clientConfig, endpoint, input, config, controller) {
-	let cancellation;
-	try {
-		cancellation = snapshotCancellationConfig(config);
-	} catch (error) {
-		return [
-			createPreflightFault("REQ_OPTIONS_INVALID", error),
-			void 0,
-			void 0
-		];
-	}
-	if (hasAbortTimeoutConflict(cancellation)) return [
-		createAbortTimeoutConflictFault(),
-		void 0,
-		void 0
-	];
-	try {
-		validateTransportTimeout(cancellation.timeout);
-	} catch (error) {
-		return [
-			createPreflightFault("REQ_OPTIONS_INVALID", error),
-			void 0,
-			void 0
-		];
-	}
-	const preAbortedSignal = [cancellation.abort, cancellation.signal].find((signal) => signal?.aborted);
-	if (preAbortedSignal) return [
-		resolveAbortedFault(preAbortedSignal),
+	const callerAbort = config.signal;
+	if (callerAbort?.aborted) return [
+		resolveAbortedFault(callerAbort),
 		void 0,
 		void 0
 	];
@@ -4390,15 +4199,8 @@ async function runEventStreamCommand(clientConfig, endpoint, input, config, cont
 			void 0
 		];
 	}
-	const deadline = armTransportDeadline(cancellation.timeout);
-	const requestSignal = mergeAbortSignals(controller.signal, [
-		cancellation.abort,
-		cancellation.signal,
-		deadline.signal
-	]);
-	deadline.releaseOnAbort(requestSignal);
+	const requestSignal = mergeAbortSignals(controller.signal, [callerAbort]);
 	const stopBeforeTransport = (fault) => {
-		deadline.release();
 		releaseAbortSignal(requestSignal);
 		return [
 			fault,
@@ -4411,28 +4213,27 @@ async function runEventStreamCommand(clientConfig, endpoint, input, config, cont
 	try {
 		parsedInput = parseEndpointInput(endpoint.input, input, inputGuides);
 	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, requestSignal, createPreflightFault("REQ_INPUT_INVALID", error)));
+		return stopBeforeTransport(resolveAbortFault(requestSignal) ?? createPreflightFault("REQ_INPUT_INVALID", error));
 	}
-	const parsedCancellation = resolveTransportCancellation(deadline, requestSignal);
+	const parsedCancellation = resolveAbortFault(requestSignal);
 	if (parsedCancellation) return stopBeforeTransport(parsedCancellation);
 	let request;
 	try {
 		request = createBaseTransportRequest(endpoint.method, endpoint.path, parsedInput, endpoint.builder, {
-			abort: requestSignal,
+			signal: requestSignal,
 			baseEndpoint: clientConfig.endpoint,
 			defaultHeaders: clientConfig.headers,
 			inputDeclared: endpoint.input !== void 0,
 			inputGuides,
 			operation: endpoint.operation,
 			querySerializer: clientConfig.querySerializer,
-			timeout: cancellation.timeout,
 			transport: "sse",
 			withCredentials: clientConfig.withCredentials
 		});
 	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, requestSignal, createPreflightFault("REQ_BUILD_FAILED", error)));
+		return stopBeforeTransport(resolveAbortFault(requestSignal) ?? createPreflightFault("REQ_BUILD_FAILED", error));
 	}
-	const builtCancellation = resolveTransportCancellation(deadline, requestSignal);
+	const builtCancellation = resolveAbortFault(requestSignal);
 	if (builtCancellation) return stopBeforeTransport(builtCancellation);
 	let chainSettled = false;
 	let streamDelivered = false;
@@ -4454,8 +4255,8 @@ async function runEventStreamCommand(clientConfig, endpoint, input, config, cont
 				rejected.catch(() => void 0);
 				return rejected;
 			}
-			const transportAbort = mergeAbortSignals(requestSignal, [req.abort]);
-			if (resolveTransportCancellation(deadline, transportAbort)) {
+			const transportAbort = mergeAbortSignals(requestSignal, [req.signal]);
+			if (resolveAbortFault(transportAbort)) {
 				const rejected = Promise.reject(transportOrigin.mark(resolveAbortCause(transportAbort)));
 				releaseAbortSignal(transportAbort);
 				rejected.catch(() => void 0);
@@ -4478,7 +4279,7 @@ async function runEventStreamCommand(clientConfig, endpoint, input, config, cont
 			const failure = {};
 			const promise = fetchEventStream({
 				...req,
-				abort: streamAbort
+				signal: streamAbort
 			}, {
 				fetch: clientConfig.sse.handle,
 				failure,
@@ -4536,7 +4337,6 @@ async function runEventStreamCommand(clientConfig, endpoint, input, config, cont
 			openInfo
 		];
 	} finally {
-		deadline.release();
 		if (!streamDelivered) releaseAbortSignal(requestSignal);
 	}
 	function discardOwnedStreams(reason, delivered) {
@@ -5330,7 +5130,7 @@ const struct = {
 function createWebSocketRequest(params) {
 	const { queryParams, queryString } = resolveTransportQuery(params.query, params.querySerializer);
 	const request = {
-		abort: params.abort,
+		signal: params.signal,
 		baseEndpoint: params.baseEndpoint,
 		endpoint: fillUrl(params.path, params.params),
 		headers: new Headers(),
@@ -5467,70 +5267,97 @@ function shouldReconnect(config, outcome, attempt) {
 * Declare a typed WebSocket endpoint.
 *
 * Pass path, incoming (and optional outgoing) message structs, and queue limits.
-* Call the returned endpoint with input to get a `WebSocketCommand` for `client.execute`.
+* Call the returned operation with a client and, when declared, the input.
 *
 * - **definition** — `path`, one `incoming` struct, and the required `maxIncomingQueueSize` (a positive safe integer). Optional `outgoing` and `input` structs, static `protocols`, `maxOutgoingQueueSize` (a non-negative safe integer), and `operation`. A declared `input` always requires an explicit `builder`. `input` only defines the parameters; the builder alone decides where each value goes. Only definitions without `input` may omit `builder`.
 *
 * A WebSocket `builder` may return `path` and `query` only; `headers` and `body` are rejected. `WebSocketDefinitionBase` and `BuilderField` are internal helper types.
 *
 * @param definition - WebSocket contract (path, structs, queue limits, optional input).
-* @returns An endpoint that creates `WebSocketCommand` values from input.
+* @returns An operation `(client, ...input) => Promise<error-first tuple>`.
 *
 * @group web-socket
 * @exampleFile examples/api/define-web-socket.ts#example
 */
 function defineWebSocket(definition) {
 	const endpoint = { ...definition };
-	function create(input) {
-		return {
-			[COMMAND_EXECUTE]: executeWebSocketCommand,
-			[COMMAND_TYPE]: WEB_SOCKET_COMMAND,
-			endpoint,
-			input
+	return (async (client, input) => {
+		const requestOptions = client[CLIENT].options;
+		const controller = new AbortController();
+		const socketState = {
+			listeners: {
+				runtimeError: /* @__PURE__ */ new Set(),
+				stateChange: /* @__PURE__ */ new Set()
+			},
+			status: "idle",
+			transition: 0
 		};
+		return runWebSocketCommand(client[CLIENT].config, endpoint, input, requestOptions, controller, socketState);
+	});
+}
+function readQueueLimits(maxIncomingQueueSize, maxOutgoingQueueSize) {
+	try {
+		validateWebSocketQueueLimits(maxIncomingQueueSize, maxOutgoingQueueSize);
+		return [void 0, true];
+	} catch (error) {
+		return [createPreflightFault("REQ_OPTIONS_INVALID", error), void 0];
 	}
-	return ((input) => create(input));
 }
-async function runWebSocketCommand(clientConfig, endpoint, input, config, controller, state) {
-	setSocketState(state, "connecting");
-	let cancellationConfig;
+function readCallOptions(config, webSocket) {
 	try {
-		cancellationConfig = snapshotCancellationConfig(config);
+		const beforeConnect = config.beforeConnect;
+		const configuredProtocols = config.protocols;
+		const protocols = configuredProtocols ? [...configuredProtocols] : void 0;
+		const reconnectOption = config.reconnect ?? webSocket.reconnect;
+		const heartbeatOption = config.heartbeat ?? webSocket.heartbeat;
+		const heartbeat = heartbeatOption ? {
+			intervalMs: heartbeatOption.intervalMs,
+			isAck: heartbeatOption.isAck,
+			message: heartbeatOption.message,
+			timeoutMs: heartbeatOption.timeoutMs
+		} : void 0;
+		validateHeartbeatConfig(heartbeat);
+		return [void 0, {
+			beforeConnect,
+			heartbeat,
+			protocols,
+			reconnect: normalizeReconnectConfig(reconnectOption)
+		}];
 	} catch (error) {
-		const definitionError = createPreflightFault("REQ_OPTIONS_INVALID", error);
-		state.error = definitionError;
-		setSocketState(state, "error");
-		return [
-			definitionError,
-			void 0,
-			void 0
-		];
+		return [createPreflightFault("REQ_OPTIONS_INVALID", error), void 0];
 	}
-	if (hasAbortTimeoutConflict(cancellationConfig)) {
-		const definitionError = createAbortTimeoutConflictFault();
-		state.error = definitionError;
-		setSocketState(state, "error");
-		return [
-			definitionError,
-			void 0,
-			void 0
-		];
+}
+function parseInput(inputStruct, input, guides, signal) {
+	try {
+		return [void 0, parseEndpointInput(inputStruct, input, guides)];
+	} catch (error) {
+		return [resolveAbortFault(signal) ?? createPreflightFault("REQ_INPUT_INVALID", error), void 0];
 	}
+}
+function buildOutbound(parsedInput, builder, inputDeclared, guides, signal) {
 	try {
-		validateTransportTimeout(cancellationConfig.timeout);
+		return [void 0, materializeOutboundRequest(runOutboundBuilder(parsedInput, builder, inputDeclared), "webSocket", guides)];
 	} catch (error) {
-		const definitionError = createPreflightFault("REQ_OPTIONS_INVALID", error);
-		state.error = definitionError;
-		setSocketState(state, "error");
-		return [
-			definitionError,
-			void 0,
-			void 0
-		];
+		return [resolveAbortFault(signal) ?? createPreflightFault("REQ_BUILD_FAILED", error), void 0];
+	}
+}
+function createSocketRequest(args) {
+	try {
+		return [void 0, createWebSocketRequest(args)];
+	} catch (error) {
+		return [resolveAbortFault(args.signal) ?? createPreflightFault("REQ_BUILD_FAILED", error), void 0];
 	}
-	const preAbortedSignal = [cancellationConfig.abort, cancellationConfig.signal].find((signal) => signal?.aborted);
-	if (preAbortedSignal) {
-		const aborted = resolveAbortedFault(preAbortedSignal);
+}
+function resolveSocketConstructor(handle) {
+	const candidate = handle ?? globalThis.WebSocket;
+	if (typeof candidate !== "function") return [createPreflightFault("ENV_UNSUPPORTED", /* @__PURE__ */ new Error("WebSocket is not supported in current runtime")), void 0];
+	return [void 0, candidate];
+}
+async function runWebSocketCommand(clientConfig, endpoint, input, config, controller, state) {
+	setSocketState(state, "connecting");
+	const callerAbort = config.signal;
+	if (callerAbort?.aborted) {
+		const aborted = resolveAbortedFault(callerAbort);
 		state.error = aborted;
 		setSocketState(state, aborted.code === "NET_ABORTED" ? "aborted" : "error");
 		return [
@@ -5539,56 +5366,26 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 			void 0
 		];
 	}
-	try {
-		validateWebSocketQueueLimits(endpoint.maxIncomingQueueSize, endpoint.maxOutgoingQueueSize);
-	} catch (error) {
-		const definitionError = createPreflightFault("REQ_OPTIONS_INVALID", error);
-		state.error = definitionError;
-		setSocketState(state, "error");
-		return [
-			definitionError,
-			void 0,
-			void 0
-		];
-	}
-	let beforeConnectOption;
-	let protocolsOption;
-	let reconnect;
-	let heartbeatConfig;
-	try {
-		beforeConnectOption = config.beforeConnect;
-		const configuredProtocols = config.protocols;
-		protocolsOption = configuredProtocols ? [...configuredProtocols] : void 0;
-		const reconnectOption = config.reconnect ?? clientConfig.webSocket.reconnect;
-		const heartbeatOption = config.heartbeat ?? clientConfig.webSocket.heartbeat;
-		heartbeatConfig = heartbeatOption ? {
-			intervalMs: heartbeatOption.intervalMs,
-			isAck: heartbeatOption.isAck,
-			message: heartbeatOption.message,
-			timeoutMs: heartbeatOption.timeoutMs
-		} : void 0;
-		validateHeartbeatConfig(heartbeatConfig);
-		reconnect = normalizeReconnectConfig(reconnectOption);
-	} catch (error) {
-		const definitionError = createPreflightFault("REQ_OPTIONS_INVALID", error);
-		state.error = definitionError;
+	const stopInvalidOptions = (fault) => {
+		state.error = fault;
 		setSocketState(state, "error");
 		return [
-			definitionError,
+			fault,
 			void 0,
 			void 0
 		];
-	}
-	const deadline = armTransportDeadline(cancellationConfig.timeout);
-	const chainSignal = mergeAbortSignals(new AbortController().signal, [
-		cancellationConfig.abort,
-		cancellationConfig.signal,
-		deadline.signal
-	]);
+	};
+	const [queueFault] = readQueueLimits(endpoint.maxIncomingQueueSize, endpoint.maxOutgoingQueueSize);
+	if (queueFault) return stopInvalidOptions(queueFault);
+	const [optionsFault, callOptions] = readCallOptions(config, clientConfig.webSocket);
+	if (optionsFault) return stopInvalidOptions(optionsFault);
+	const beforeConnectOption = callOptions.beforeConnect;
+	const protocolsOption = callOptions.protocols;
+	const reconnect = callOptions.reconnect;
+	const heartbeatConfig = callOptions.heartbeat;
+	const chainSignal = mergeAbortSignals(new AbortController().signal, [callerAbort]);
 	const signal = mergeAbortSignals(controller.signal, [chainSignal]);
-	deadline.releaseOnAbort(chainSignal);
 	const stopBeforeTransport = (fault) => {
-		deadline.release();
 		releaseAbortSignal(chainSignal);
 		releaseAbortSignal(signal);
 		state.error = fault;
@@ -5600,39 +5397,28 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 		];
 	};
 	const inputGuides = /* @__PURE__ */ new WeakMap();
-	let parsedInput;
-	try {
-		parsedInput = parseEndpointInput(endpoint.input, input, inputGuides);
-	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, signal, createPreflightFault("REQ_INPUT_INVALID", error)));
-	}
-	const parsedCancellation = resolveTransportCancellation(deadline, signal);
+	const [inputFault, parsedInput] = parseInput(endpoint.input, input, inputGuides, signal);
+	if (inputFault) return stopBeforeTransport(inputFault);
+	const parsedCancellation = resolveAbortFault(signal);
 	if (parsedCancellation) return stopBeforeTransport(parsedCancellation);
-	let built;
-	try {
-		built = materializeOutboundRequest(runOutboundBuilder(parsedInput, endpoint.builder, endpoint.input !== void 0), "webSocket", inputGuides);
-	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, signal, createPreflightFault("REQ_BUILD_FAILED", error)));
-	}
-	const builtCancellation = resolveTransportCancellation(deadline, signal);
+	const [buildFault, built] = buildOutbound(parsedInput, endpoint.builder, endpoint.input !== void 0, inputGuides, signal);
+	if (buildFault) return stopBeforeTransport(buildFault);
+	const builtCancellation = resolveAbortFault(signal);
 	if (builtCancellation) return stopBeforeTransport(builtCancellation);
-	let wsRequest;
-	try {
-		wsRequest = createWebSocketRequest({
-			abort: signal,
-			baseEndpoint: clientConfig.endpoint,
-			operation: endpoint.operation,
-			params: built.params,
-			path: endpoint.path,
-			query: built.query,
-			querySerializer: clientConfig.querySerializer,
-			withCredentials: clientConfig.withCredentials
-		});
-	} catch (error) {
-		return stopBeforeTransport(resolveTransportCancellation(deadline, signal, createPreflightFault("REQ_BUILD_FAILED", error)));
-	}
-	const WebSocketCtor = clientConfig.webSocket.handle ?? globalThis.WebSocket;
-	if (typeof WebSocketCtor !== "function") return stopBeforeTransport(createPreflightFault("ENV_UNSUPPORTED", /* @__PURE__ */ new Error("WebSocket is not supported in current runtime")));
+	const [requestFault, wsRequest] = createSocketRequest({
+		signal,
+		baseEndpoint: clientConfig.endpoint,
+		operation: endpoint.operation,
+		params: built.params,
+		path: endpoint.path,
+		query: built.query,
+		querySerializer: clientConfig.querySerializer,
+		withCredentials: clientConfig.withCredentials
+	});
+	if (requestFault) return stopBeforeTransport(requestFault);
+	const constructorStage = resolveSocketConstructor(clientConfig.webSocket.handle);
+	if (constructorStage[0]) return stopBeforeTransport(constructorStage[0]);
+	const WebSocketCtor = constructorStage[1];
 	const WebSocketImpl = WebSocketCtor;
 	let startupConnection;
 	const undeliveredSessions = /* @__PURE__ */ new Set();
@@ -5648,7 +5434,7 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 		wsHandlerInvoked = true;
 		const executionSignal = signal;
 		const pendingSession = new Promise((resolveSession, rejectSession) => {
-			const signal = mergeAbortSignals(executionSignal, [req.abort]);
+			const signal = mergeAbortSignals(executionSignal, [req.signal]);
 			const incomingQueue = new AsyncQueue({ maxSize: endpoint.maxIncomingQueueSize });
 			const closedDeferred = Promise.withResolvers();
 			const sessionController = {
@@ -5800,15 +5586,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 				};
 			}
 			async function connectOnce(url, protocols) {
-				const due = resolveTransportCancellation(deadline, signal);
-				if (due) return {
-					cause: due,
-					closeInfo: {
-						cause: due,
-						reason: due.message
-					},
-					opened: false
-				};
 				let socket;
 				try {
 					socket = protocols.length > 0 ? new WebSocketImpl(url, [...protocols]) : new WebSocketImpl(url);
@@ -5900,7 +5677,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 						if (!startupSettled) {
 							startupConnection = latestConnection;
 							startupSettled = true;
-							deadline.release();
 							resolveSession(session);
 						}
 						if (state.status === "open") startHeartbeat(socket, sessionController, heartbeatConfig, endpoint.outgoing, (cause) => {
@@ -6047,7 +5823,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 				/* istanbul ignore if -- @preserve defensive once-only gate: terminal callers and reentrant state transitions check finished before invoking finish */
 				if (finished) return;
 				finished = true;
-				deadline.release();
 				stopHeartbeat(sessionController);
 				const activeSocket = sessionController.currentSocket;
 				if (final.kind !== "closed" && activeSocket && !options.skipNativeClose) requestNativeCloseBestEffort(activeSocket);
@@ -6162,7 +5937,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 		const publicConnection = session?.connection;
 		if (typeof session?.closed?.then !== "function" || typeof session.close !== "function" || typeof session.send !== "function" || typeof session.receive?.[Symbol.asyncIterator] !== "function" || typeof session[Symbol.asyncDispose] !== "function" || typeof session.onRuntimeError !== "function" || typeof session.onStateChange !== "function" || typeof publicConnection?.generation !== "number" || typeof session.bufferedAmount !== "number" || typeof session.state !== "string") throw new TypeError("WebSocket interceptor must resolve a WebSocket session");
 		chainSettled = true;
-		deadline.release();
 		releaseAbortSignal(chainSignal);
 		let deliveredSession = [...undeliveredSessions].some((createdSession) => createdSession === session || createdSession.closed === session.closed);
 		const pendingSessionSnapshot = [...pendingSessions];
@@ -6188,7 +5962,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 		];
 	} catch (error) {
 		chainSettled = true;
-		deadline.release();
 		releaseAbortSignal(chainSignal);
 		const signalError = resolveAbortFault(chainSignal);
 		const requestError = signalError ?? (isFault(error) ? error : createPreflightFault("EXT_INTERCEPTOR_FAILED", error));
@@ -6212,32 +5985,6 @@ async function runWebSocketCommand(clientConfig, endpoint, input, config, contro
 		];
 	}
 }
-/**
-* Open a WebSocket command against the given client config.
-*
-* Prefer `client.execute(command)` in application code; this is the low-level entry used by the client.
-*
-* The result is `[null, session, connection]` or `[fault, undefined, connection | undefined]`, where the fault is `Fault<undefined>`.
-*
-* WebSocket execute options can override the client's `beforeConnect`, `heartbeat`, `protocols`, and `reconnect`.
-*
-* @param clientConfig - Resolved client configuration.
-* @param command - WebSocket command from a `WebSocketEndpoint`.
-* @param options - Optional execute options (heartbeat, reconnect, abort).
-* @returns Await-result tuple of `[error, socket, connection]`.
-* @group web-socket
-*/
-async function executeWebSocketCommand(clientConfig, command, options) {
-	const { endpoint, input } = command;
-	return runWebSocketCommand(clientConfig, endpoint, input, options ?? {}, new AbortController(), {
-		listeners: {
-			runtimeError: /* @__PURE__ */ new Set(),
-			stateChange: /* @__PURE__ */ new Set()
-		},
-		status: "idle",
-		transition: 0
-	});
-}
 const SOCKET_CLOSE_GRACE_MS = 1e3;
 const noop = () => void 0;
 function createWebSocketSession(outgoing, queue, closed, state, sessionController, sendQueue, maxOutgoingQueueSize, openState, isUnavailable, requestClose, disposeSession) {
@@ -6413,4 +6160,4 @@ function faultFromCloseInfo(closeInfo) {
 function isFault(value) {
 	return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" && value instanceof Error;
 }
-export { ERR_ABORTED, ERR_TIMEOUT, StructError, basicAuthHttpInterceptor, basicAuthSSEInterceptor, createClient, createDecodeFault, createHttpInterceptor, createHttpStatusFault, createNetworkFault, createPreflightFault, createResolvedRequestUrl, createSSEInterceptor, createUndecodedHttpStatusFault, createWebSocketInterceptor, defineEventStream, defineRequest, defineWebSocket, executeEventStreamCommand, executeHttpCommand, executeWebSocketCommand, fetchHandler, isAbortCause, isTimeoutCause, makeResponse, struct, withCredentials, withEndpoint, withHTTPHandle, withHeaders, withInterceptors, withQuerySerializer, withSSEHandle, withSSEOnInvalidEvent, withSSEReconnect, withTimeout, withWebSocketBeforeConnect, withWebSocketHandle, withWebSocketHeartbeat, withWebSocketProtocols, withWebSocketReconnect, withXSRF };
+export { ERR_ABORTED, ERR_TIMEOUT, StructError, basicAuthHttpInterceptor, basicAuthSSEInterceptor, createClient, createDecodeFault, createHttpInterceptor, createHttpStatusFault, createNetworkFault, createPreflightFault, createResolvedRequestUrl, createSSEInterceptor, createUndecodedHttpStatusFault, createWebSocketInterceptor, defineEventStream, defineRequest, defineWebSocket, fetchHandler, isAbortCause, isTimeoutCause, makeResponse, struct, withCredentials, withEndpoint, withHTTPHandle, withHeaders, withInterceptors, withQuerySerializer, withSSEHandle, withSSEOnInvalidEvent, withSSEReconnect, withWebSocketBeforeConnect, withWebSocketHandle, withWebSocketHeartbeat, withWebSocketProtocols, withWebSocketReconnect, withXSRF };