@defjs/core 0.4.0 → 0.5.0

package/index.d.ts

@@ -37,8 +37,8 @@ interface HttpProgressEvent {
  * Callbacks may be async and are awaited before the next chunk is processed. A
  * callback that throws or rejects fails the call with `EXT_OBSERVER_FAILED`,
  * with the thrown value as `cause`, for downloads and uploads alike. Caller
- * cancellation and `timeout` still take precedence and report `NET_ABORTED` or
- * `NET_TIMEOUT`.
+ * cancellation still takes precedence and reports `NET_ABORTED`, or `NET_TIMEOUT`
+ * when the abort reason is a timeout.
  *
  * Upload progress for a `Blob`, `File`, `ArrayBuffer`, or `FormData` body is
  * reported only where the runtime can stream request bodies (Bun, Node). In
@@ -48,8 +48,8 @@ interface HttpProgressEvent {
  *
  * On server runtimes, FormData with `onUploadProgress` reads its serialized
  * stream directly, keeps its multipart boundary, and is sent without a
- * library-generated `Content-Length` (chunked over HTTP/1.1), so progress,
- * timeout, and abort work without buffering the whole body. It reports an
+ * library-generated `Content-Length` (chunked over HTTP/1.1), so progress
+ * and abort work without buffering the whole body. It reports an
  * unknown total unless a valid explicit `Content-Length` supplies it. For an
  * endpoint that requires `Content-Length`, such as some presigned upload
  * targets, omit `onUploadProgress`; platform Fetch then sends FormData with its
@@ -111,7 +111,6 @@ interface HttpRequest {
    * unread and does not fall back to `responseType`.
    */
   readonly errorResponseType?: HttpResponseType;
-  timeout?: number;
   uploadProgress?: HttpProgressFn;
   withCredentials?: boolean;
   xsrf?: {
@@ -501,7 +500,7 @@ interface PreservedStruct<T, I, O, OO extends boolean> extends Struct<I, O, OO>,
 /**
  * Broad struct constraint that accepts any struct, for endpoint and client generics.
  *
- * Used by generics such as `defineRequest`, `Fault`, and `HttpCommand`. Prefer a concrete `Struct<…>` when you need precise input and output inference.
+ * Used by generics such as `defineRequest` and `Fault`. Prefer a concrete `Struct<…>` when you need precise input and output inference.
  *
  * @group struct
  */
@@ -655,7 +654,7 @@ interface IntersectionStruct<T extends readonly StructLike<unknown, unknown, boo
  * | Class  | Meaning                                                        |
  * | ------ | -------------------------------------------------------------- |
  * | `HTTP` | The peer answered with a non-2xx status.                        |
- * | `REQ`  | The request never left: input, execute options, or build.       |
+ * | `REQ`  | The request never left: input, request options, or build.       |
  * | `NET`  | No usable response: cancel, timeout, connect, truncated body.   |
  * | `RES`  | A response arrived but could not be read as declared.           |
  * | `EXT`  | Code you attached to the pipeline threw.                        |
@@ -762,7 +761,7 @@ export type PreflightFault = Error & {
   response?: HttpMeta;
 };
 /**
- * Any failure returned by `client.execute`, expressed by its decoded error-body type.
+ * Any failure returned by an operation, expressed by its decoded error-body type.
  *
  * `Fault<TErr>` is `FaultOf` applied to `Infer<TErr>`, and `HttpAwaitResult` uses
  * `FaultOf<TErrorData>`. Pass a decoded type, not a struct: write
@@ -773,7 +772,7 @@ export type PreflightFault = Error & {
  */
 export type FaultOf<TData = undefined> = DecodeFault | HttpStatusFaultOf<TData> | PreflightFault;
 /**
- * Union of every failure `client.execute` can return, discriminated by `code`.
+ * Union of every failure an operation can return, discriminated by `code`.
  *
  * `Fault<TErr>` is {@link FaultOf} applied to the decoded body type, so it is the
  * union of {@link DecodeFault}, {@link HttpStatusFault}<TErr>, and
@@ -1380,7 +1379,7 @@ interface EventStreamMessage {
 /**
  * Metadata available once an SSE response has opened.
  *
- * `response` is the handshake response and `url` is the resolved request URL. It is the third element of a successful `client.execute` result and the value of `EventStreamHandle.open`.
+ * `response` is the handshake response and `url` is the resolved request URL. It is the third element of a successful event-stream result and the value of `EventStreamHandle.open`.
  *
  * @group sse
  */
@@ -1420,7 +1419,7 @@ type EventStreamCloseInfo = (EventStreamCloseInfoBase & {
 /**
  * Open SSE stream: iterate events, read open metadata, and close early.
  *
- * `EventStreamMessage` is the raw `{ id: string; event: string; data: string }` message. Handles returned by `client.execute` carry parsed {@link EventStreamData}.
+ * `EventStreamMessage` is the raw `{ id: string; event: string; data: string }` message. Handles returned by an event-stream operation carry parsed {@link EventStreamData}.
  *
  * `open` is the startup snapshot ({@link EventStreamOpenInfo}); after a reconnect it can change, so read `stream.open` again. `closed` resolves with an {@link EventStreamCloseInfo} when the stream ends.
  *
@@ -1443,16 +1442,8 @@ interface EventStreamHandle<TEvent = EventStreamMessage> extends AsyncIterable<T
   close(reason?: unknown): void;
   [Symbol.asyncDispose](): PromiseLike<void>;
 }
-type UseCancellationConfig = {
-  abort?: AbortSignal;
-  timeout?: never;
-} | {
-  abort?: never;
-  timeout?: number;
-};
-type EndpointInput<TInput extends AnyStruct | undefined> = TInput extends AnyStruct ? StructInput<TInput> : unknown;
-type IsEndpointInputOptional<TInput extends AnyStruct | undefined> = [TInput] extends [undefined] ? true : undefined extends EndpointInput<TInput> ? true : false;
-type EndpointCallable<TInput extends AnyStruct | undefined, TCommand> = [TInput] extends [undefined] ? () => TCommand : IsEndpointInputOptional<TInput> extends true ? (input?: EndpointInput<TInput>) => TCommand : (input: EndpointInput<TInput>) => TCommand;
+/** Argument list after the client, decided by the input struct. */
+type EndpointArgs<S extends AnyStruct | undefined> = [S] extends [undefined] ? [] : undefined extends StructInput<S> ? [input?: StructInput<S>] : [input: StructInput<S>];
 /** Object produced by endpoint input parsing. The symbol points at the struct that produced the node. */
 type Typed = {
   readonly [STRUCT]: AnyStruct;
@@ -1570,359 +1561,14 @@ type BuilderInput<S> = S extends CarriedStruct<infer Inner> ? NullishBuilderInpu
   [key: string]: BuilderInput<Value>;
 } : S extends TupleStruct<infer Items> ? { [K in keyof Items]: Items[K] extends StructLike<unknown, unknown, boolean> ? BuilderInput<Items[K]> : Items[K]; } : S extends ArrayStruct<infer Item> ? BuilderInput<Item>[] : S extends ObjectStruct<infer Shape> ? { [K in keyof Shape]: BuilderInput<Shape[K]>; } & Typed : Infer<S>;
 type BuilderField<TInput, TShape> = [TInput] extends [undefined] ? {
-  /** Pure, synchronous request builder, evaluated when the command runs. Optional without input. */
+  /** Pure, synchronous request builder, evaluated when the operation runs. Optional without input. */
   builder?: () => TShape;
 } : {
-  /** Pure, synchronous function that explicitly places parsed input on the request when the command runs. */
+  /** Pure, synchronous function that explicitly places parsed input on the request when the operation runs. */
   builder: (input: BuilderInput<TInput>) => TShape;
 };
 /** Accepts any concrete builder. `never` keeps the parameter contravariant. */
 type OutboundBuilder = (input: never) => unknown;
-/**
- * Per-request options for HTTP execution: progress callbacks and cancellation.
- *
- * The HTTP-specific part of {@link HttpExecuteOptions}, which adds `signal`.
- * `onDownloadProgress` and `onUploadProgress` are {@link HttpProgressFn}
- * callbacks. They receive an {@link HttpProgressEvent} with `loaded`, `total`,
- * and `lengthComputable`.
- *
- * Cancellation is either `abort` or `timeout`, never both. The type rejects
- * both, and at runtime passing both fails with a `REQ_OPTIONS_INVALID` fault.
- * `timeout` must be a positive safe integer no greater than `2_147_483_647`.
- * It replaces the default set by {@link withTimeout} for that call. `abort`
- * combines with that default instead.
- *
- * @group http
- */
-export type UseRequestConfig = {
-  onDownloadProgress?: HttpProgressFn;
-  onUploadProgress?: HttpProgressFn;
-} & UseCancellationConfig;
-/**
- * Opaque executable HTTP command produced by a `defineRequest` endpoint.
- *
- * Created by calling a `RequestEndpoint` with input. It carries the request
- * definition and optional typed input for `client.execute`. Treat it as opaque
- * and pass it to `client.execute`.
- *
- * @group http
- */
-export interface HttpCommand<TInput extends AnyStruct | undefined, TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined = undefined> extends BaseCommand<typeof HTTP_COMMAND> {
-  readonly definition: RequestDefinition<TInput, TOutput, TError>;
-  readonly input: EndpointInput<TInput> | undefined;
-}
-/**
- * Options passed to `client.execute` or `executeHttpCommand` for one HTTP call: progress, `abort` or `timeout`, and `signal`.
- *
- * Cancellation is `abort` or `timeout`, not both (`abort` XOR `timeout`).
- * `signal` combines with either; it is not an alias for `abort`. Valid shapes:
- * `{ timeout }`, `{ abort }`, `{ signal, timeout }`, `{ signal, abort }`.
- * `{ abort, timeout }` is invalid and makes the call resolve with a
- * `REQ_OPTIONS_INVALID` fault. `timeout` must be a positive safe integer in
- * `1..2_147_483_647`.
- *
- * When `timeout` is omitted, the client's `withTimeout` default applies;
- * `abort` combines with that default.
- *
- * @group http
- */
-export type HttpExecuteOptions = UseRequestConfig & {
-  signal?: AbortSignal;
-};
-/**
- * Callable endpoint returned by `defineRequest`.
- *
- * Call it to get an `HttpCommand`: with no arguments when the endpoint declares
- * no `input`, with an optional argument when the input struct accepts
- * `undefined`, and otherwise with the struct's input value.
- *
- * @group http
- */
-export type RequestEndpoint<TInput extends AnyStruct | undefined, TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined = undefined> = EndpointCallable<TInput, HttpCommand<TInput, TOutput, TError>>;
-type DeclaredBody<TStruct> = [TStruct] extends [undefined] ? undefined : Infer<TStruct>;
-type DeclaredResponse<TStruct> = [TStruct] extends [undefined] ? HttpMeta : DecodedResponse<Infer<TStruct>>;
-/**
- * Decoded success body for the declared `output` struct, or `undefined` when none is declared.
- *
- * @group http
- */
-export type RequestSuccessData<TOutput extends AnyStruct | undefined> = DeclaredBody<TOutput>;
-/**
- * Decoded error body for the declared `error` struct, or `undefined` when none is declared.
- *
- * @group http
- */
-export type RequestErrorData<TError extends AnyStruct | undefined> = DeclaredBody<TError>;
-type ResponseDeclaration<TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined> = ([TOutput] extends [undefined] ? {
-  output?: never;
-} : {
-  output: TOutput;
-}) & ([TError] extends [undefined] ? {
-  error?: never;
-} : {
-  error: TError;
-});
-/**
- * Contract for an HTTP endpoint: method, path, optional input, and the structs that decode its bodies.
- *
- * Declaring `input` requires an explicit `builder` to place the parsed value on
- * the request. `input` only defines the parameters; the builder alone decides
- * where each value goes. Only definitions without `input` may omit `builder`.
- * `output` declares the body for a 2xx response, `error` the body for anything
- * else. Only one of the two ever runs, and omitting one means that body is never
- * read. `ResponseDeclaration` is an internal helper type: `output` and `error`
- * are required only when the matching type parameter is a struct. There is no
- * `responseType`: the struct kind selects how a declared body is read. Pass to
- * `defineRequest` to get a typed endpoint.
- *
- * @group http
- */
-export type RequestDefinition<TInput extends AnyStruct | undefined = undefined, TOutput extends AnyStruct | undefined = undefined, TError extends AnyStruct | undefined = undefined> = ResponseDeclaration<TOutput, TError> & {
-  builder?: OutboundBuilder;
-  input?: TInput;
-  method: string;
-  operation?: string;
-  path: string;
-};
-/**
- * Await-result tuple for an HTTP call: success is `[null, data, response]`, and failure is `[fault, undefined, undefined]`.
- *
- * `TData` and `TErrorData` are decoded body types. On success the third slot
- * carries `body` only when `output` was declared. On failure it is `undefined`,
- * because the fault already holds whatever response metadata existed.
- *
- * @group http
- */
-export type HttpAwaitResult<TData = undefined, TErrorData = undefined> = [error: null, result: TData, response: [TData] extends [undefined] ? HttpMeta : DecodedResponse<TData>] | [error: FaultOf<TErrorData>, result: undefined, response: undefined];
-type HttpExecuteAwaitResult<TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined> = [error: null, result: RequestSuccessData<TOutput>, response: DeclaredResponse<TOutput>] | [error: Fault<TError>, result: undefined, response: undefined];
-/**
- * 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`.
- *
- * The contract is `method`, `path`, an optional `input` struct, optional
- * `output` and `error` structs, and an optional `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`. `ResponseDeclaration` and `BuilderField` are
- * internal helper types: `output` and `error` are required only when the
- * matching type parameter is a struct, and `builder` is
- * `(input: BuilderInput<TInput>) => HttpRequestShape` when `input` is declared.
- *
- * `output` is one struct for the 2xx body; `error` is one struct for every
- * non-2xx body. Neither is keyed by status. A declaration is an assertion:
- * 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.
- *
- * The checked example file passes the whole input object as `path`. This snippet maps individual fields into `path` and `query` instead:
- *
- * @example
- * ```ts
- * const getUser = defineRequest({
- *   method: 'GET',
- *   path: '/users/:id',
- *   input: struct.object({ id: struct.number(), verbose: struct.boolean() }),
- *   builder: (input) => ({ path: { id: input.id }, query: { verbose: input.verbose } }),
- *   output: struct.object({ id: struct.number(), name: struct.string() }),
- * })
- * ```
- * @group http
- * @exampleFile examples/api/define-request.ts#example
- */
-export declare function defineRequest<const M extends string, const P extends string, TInput extends AnyStruct | undefined = undefined, TOutput extends AnyStruct | undefined = undefined, TError extends AnyStruct | undefined = undefined>(definition: ResponseDeclaration<TOutput, TError> & {
-  input?: TInput;
-  method: M;
-  operation?: string;
-  path: P;
-} & BuilderField<NoInfer<TInput>, HttpRequestShape<NoInfer<P>, NoInfer<M>>>): RequestEndpoint<TInput, TOutput, TError>;
-/**
- * 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
- */
-export declare function executeHttpCommand<TInput extends AnyStruct | undefined, TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined>(clientConfig: HttpClientConfig, command: HttpCommand<TInput, TOutput, TError>, options?: HttpExecuteOptions): Promise<HttpExecuteAwaitResult<TOutput, TError>>;
-/**
- * Map from SSE event names to the structs that decode their data.
- *
- * An event with no `event:` field is named `message`. An event whose name has no own entry uses the `default` struct; with neither, the event is skipped and `onInvalidEvent` is called. Declare the event name `__proto__` with a computed own key.
- *
- * A `string` event struct keeps the raw `data` text. Every other kind is JSON text: `JSON.parse`, then the struct. A bare `struct.literal` therefore needs JSON text, not an unquoted token.
- *
- * Reconnect lives on the client (`withSSEReconnect`). SSE `jitter` is a **0-1 multiplicative factor**, same as WebSocket.
- *
- * @group sse
- */
-export type EventStructs = {
-  [key: string]: AnyStruct;
-};
-type EventName<TKey extends string | number> = `${TKey}`;
-type KnownEventUnion<TEvents extends EventStructs> = { [K in keyof TEvents & (number | string)]: EventName<K> extends "default" ? never : {
-  data: Infer<TEvents[K]>;
-  event: EventName<K>;
-  id?: string;
-}; }[keyof TEvents & (number | string)];
-type DefaultEventUnion<TEvents extends EventStructs> = "default" extends keyof TEvents ? {
-  data: Infer<TEvents["default"]>;
-  event: string;
-  id?: string;
-} : never;
-/**
- * Union of parsed SSE events inferred from an EventStructs map.
- *
- * For each declared event name except `default`, the union has `{ event: <name>; data: Infer<TEvents[name]>; id?: string }`. When a `default` struct is declared, it adds `{ event: string; data: Infer<TEvents['default']>; id?: string }` for every event name that has no struct of its own. `KnownEventUnion` and `DefaultEventUnion` are internal helper types.
- *
- * @group sse
- */
-export type EventStreamData<TEvents extends EventStructs> = TEvents extends EventStructs ? KnownEventUnion<TEvents> | DefaultEventUnion<TEvents> : never;
-interface EventStreamDefinitionBase<TEvents extends EventStructs = EventStructs> {
-  events: TEvents;
-  maxBufferSize: number;
-  maxQueueSize: number;
-  method?: string;
-  operation?: string;
-  path: string;
-}
-/** Makes `error` required only when an error struct is declared, so omission stays `Fault<undefined>`. */
-type EventStreamErrorField<TError extends AnyStruct | undefined> = [TError] extends [undefined] ? {
-  error?: never;
-} : {
-  error: TError;
-};
-/**
- * Contract that describes an SSE endpoint for defineEventStream.
- *
- * The composed members are:
- *
- * - `events`, `maxBufferSize`, and `maxQueueSize` (both limits are required positive safe integers), optional `method`, `operation`, and a required `path`.
- *
- * - `error`, required only when `TError` is a struct. It decodes the body of a failed handshake (a non-2xx response). The kind rule is the same as for HTTP: `string` is text, `blob` and `file` are blobs, `arrayBuffer` is bytes, and everything else is JSON.
- *
- * - `input` and `builder`. The request shape matches HTTP, including `body`; `GET` and `HEAD` cannot return a body. 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` and `EventStreamErrorField` are internal helper types.
- *
- * @group sse
- */
-export type EventStreamDefinition<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs, TError extends AnyStruct | undefined = undefined> = EventStreamDefinitionBase<TEvents> & EventStreamErrorField<TError> & {
-  builder?: OutboundBuilder;
-  input?: TInput;
-};
-/**
- * Await-result tuple from opening an SSE stream via `client.execute`.
- *
- * - On success: `[null, stream, open]`. `open` is the returned connection's first successful handshake snapshot for native Defjs handles or wrappers forwarding the same live `open` object; custom handles or wrappers overriding `open` use their current public `open` even after reconnect, while `stream.open` stays live.
- *
- * - On failure: `[fault, undefined, open]`. `open` carries the response snapshot when the failure happened after a response arrived, for example a non-2xx handshake, and is `undefined` otherwise.
- *
- * - `TError` is the declared `error` struct. It types the decoded error body on the fault.
- *
- * @group sse
- */
-export type StreamAwaitResult<TEvent, TError extends AnyStruct | undefined = undefined> = [error: null, stream: EventStreamHandle<TEvent>, open: EventStreamOpenInfo] | [error: Fault<TError>, stream: undefined, open: EventStreamOpenInfo | undefined];
-/**
- * Opaque executable SSE command produced by an `EventStreamEndpoint`.
- *
- * Created by calling an `EventStreamEndpoint` with input. It also has internal symbol-keyed members that identify and run the command. Treat it as opaque and pass it to `client.execute`. `endpoint` is the definition plus `method`, which is always a string (it defaults to `'GET'` when the definition omits it). `ResolvedEventStreamDefinition` names that shape and is not exported.
- *
- * @group sse
- */
-export interface EventStreamCommand<TInput extends AnyStruct | undefined, TEvents extends EventStructs, TError extends AnyStruct | undefined = undefined> extends BaseCommand<typeof EVENT_STREAM_COMMAND> {
-  readonly endpoint: ResolvedEventStreamDefinition<TInput, TEvents, TError>;
-  readonly input: EndpointInput<TInput> | undefined;
-}
-/**
- * Per-call options for opening an SSE stream: abort or timeout, plus an optional signal.
- *
- * Cancellation is `abort` **or** `timeout`, not both; passing both makes the call resolve with a `REQ_OPTIONS_INVALID` fault. `signal` combines with either and is not an alias for `abort`. `timeout` must be a positive safe integer up to 2147483647.
- *
- * For SSE, `timeout` is a startup deadline. It covers input parsing, the builder, the interceptors, and opening the connection, and stops applying once the stream is open. The client-level `withTimeout` default does not apply to SSE.
- *
- * @group sse
- */
-export type EventStreamExecuteOptions = UseCancellationConfig & {
-  signal?: AbortSignal;
-};
-/**
- * Callable endpoint returned by defineEventStream.
- *
- * Returned by `defineEventStream`. Call it to get an `EventStreamCommand`: with no arguments when the endpoint declares no `input`, with an optional argument when the input struct accepts `undefined`, and otherwise with the struct's input value.
- *
- * @group sse
- */
-export type EventStreamEndpoint<TInput extends AnyStruct | undefined, TEvents extends EventStructs, TError extends AnyStruct | undefined = undefined> = EndpointCallable<TInput, EventStreamCommand<TInput, TEvents, TError>>;
-type ResolvedEventStreamDefinition<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs, TError extends AnyStruct | undefined = undefined> = EventStreamDefinition<TInput, TEvents, TError> & {
-  readonly method: string;
-};
-/**
- * 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`.
- *
- * - **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.
- *
- * @group sse
- * @exampleFile examples/api/define-event-stream.ts#example
- */
-export declare function defineEventStream<const P extends string, const M extends string = "GET", TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs, TError extends AnyStruct | undefined = undefined>(definition: Omit<EventStreamDefinitionBase<TEvents>, "method" | "path"> & EventStreamErrorField<TError> & {
-  input?: TInput;
-  method?: M;
-  path: P;
-} & BuilderField<NoInfer<TInput>, EventStreamRequestShape<NoInfer<P>, NoInfer<M>>>): EventStreamEndpoint<TInput, TEvents, TError>;
-/**
- * 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
- */
-export declare function executeEventStreamCommand<TInput extends AnyStruct | undefined, TEvents extends EventStructs, TError extends AnyStruct | undefined = undefined>(clientConfig: ClientConfig, command: EventStreamCommand<TInput, TEvents, TError>, options?: EventStreamExecuteOptions): Promise<StreamAwaitResult<EventStreamData<TEvents>, TError>>;
-declare const COMMAND_TYPE: unique symbol;
-declare const HTTP_COMMAND: unique symbol;
-declare const EVENT_STREAM_COMMAND: unique symbol;
-declare const WEB_SOCKET_COMMAND: unique symbol;
-/** The command's own runner, so `client.execute` never imports a transport the app does not use. */
-declare const COMMAND_EXECUTE: unique symbol;
-type CommandExecutor = (config: ClientConfig, command: never, options?: never) => Promise<unknown>;
-type CommandType = typeof HTTP_COMMAND | typeof EVENT_STREAM_COMMAND | typeof WEB_SOCKET_COMMAND;
-interface BaseCommand<TCommandType extends CommandType> {
-  readonly [COMMAND_EXECUTE]: CommandExecutor;
-  readonly [COMMAND_TYPE]: TCommandType;
-}
 interface WebSocketCloseSnapshot {
   cause?: unknown;
   code?: number;
@@ -1982,13 +1628,13 @@ interface WebSocketDefinitionBase<TIncoming extends AnyStruct = AnyStruct, TOutg
  *
  * - `maxIncomingQueueSize` is required and must be a positive safe integer. `maxOutgoingQueueSize` must be a non-negative safe integer; it defaults to `0`, which disables queueing of messages sent while the session is `reconnecting`.
  *
- * - `protocols` is the static default subprotocol list. The `protocols` execute option and {@link withWebSocketProtocols} override it.
+ * - `protocols` is the static default subprotocol list. `RequestOptions.protocols` and {@link withWebSocketProtocols} override it.
  *
  * - `operation` is a static, low-cardinality name for telemetry.
  *
- * - `input` is the struct for the command input. 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`. The builder may return `path` and `query` only; see {@link WebSocketRequestShape}.
+ * - `input` is the struct for the operation input. 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`. The builder may return `path` and `query` only; see {@link WebSocketRequestShape}.
  *
- * Invalid queue limits are reported when the command executes, as a `REQ_OPTIONS_INVALID` fault.
+ * Invalid queue limits are reported when the operation runs, as a `REQ_OPTIONS_INVALID` fault.
  *
  * @group web-socket
  */
@@ -2005,7 +1651,7 @@ export type WebSocketDefinition<TInput extends AnyStruct | undefined = undefined
  *
  * - `generation` counts the physical sockets that reached `open`: `1` after the first open, one more after each reconnect. A snapshot taken before any open has `0`.
  *
- * `session.connection` exposes the session's current public connection info. The `connection` in the execute result preserves the first successful snapshot only for a native Defjs session or a wrapper forwarding the same live `connection` object. Custom sessions and wrappers that transform `connection` instead return their current public `connection`. Sharing `closed` cannot bypass URL sanitization or metadata filtering, and Defjs does not reconstruct first-connection metadata from arbitrary transformations.
+ * `session.connection` exposes the session's current public connection info. The `connection` in the operation result preserves the first successful snapshot only for a native Defjs session or a wrapper forwarding the same live `connection` object. Custom sessions and wrappers that transform `connection` instead return their current public `connection`. Sharing `closed` cannot bypass URL sanitization or metadata filtering, and Defjs does not reconstruct first-connection metadata from arbitrary transformations.
  *
  * @group web-socket
  */
@@ -2093,7 +1739,7 @@ export interface WebSocketSession<TIncoming = unknown, TOutgoing = never> extend
   send(message: TOutgoing): void;
 }
 /**
- * Await-result tuple from opening a WebSocket via `client.execute`.
+ * Await-result tuple from opening a WebSocket.
  *
  * - On success: `[null, session, connection]`. `session.connection` moves forward on reconnect. The tuple's `connection` preserves the first successful snapshot only for a native Defjs session or a wrapper forwarding the same live `connection` object. Custom sessions and wrappers that transform `connection` instead return their current public `connection`. Sharing `closed` cannot bypass URL sanitization or metadata filtering, and Defjs does not reconstruct first-connection metadata from arbitrary transformations.
  *
@@ -2111,83 +1757,33 @@ interface UseWebSocketBaseConfig<TIncoming = unknown, TOutgoing = unknown> {
   reconnect?: ClientWebSocketOptions["reconnect"];
 }
 /**
- * WebSocket execute options without signal.
- *
- * The WebSocket-specific part of {@link WebSocketExecuteOptions}, which adds `signal`.
- *
- * - `beforeConnect`, `heartbeat`, `protocols`, and `reconnect` override the client-level options for one call.
- *
- * - Cancellation is either `abort` or `timeout`, never both. The type rejects both, and at runtime passing both fails with a `REQ_OPTIONS_INVALID` fault.
- *
- * @group web-socket
- */
-export type UseWebSocketConfig<TIncoming = unknown, TOutgoing = unknown> = UseWebSocketBaseConfig<TIncoming, TOutgoing> & UseCancellationConfig;
-/**
- * Per-call options for executing a WebSocket command.
+ * WebSocket fields of {@link RequestOptions}, plus `abort`.
  *
- * {@link UseWebSocketConfig} plus `signal`. Expanded:
- *
- * ```ts
- * type WebSocketExecuteOptions<TIncoming = unknown, TOutgoing = unknown> = {
- *   beforeConnect?: (context: {
- *     attempt: number;
- *     signal: AbortSignal;
- *   }) => void | Promise<void>;
- *   heartbeat?: WebSocketHeartbeatConfig<TIncoming, TOutgoing>;
- *   protocols?: readonly string[];
- *   reconnect?: ClientWebSocketOptions["reconnect"];
- *   signal?: AbortSignal;
- * } & (
- *   { abort?: AbortSignal; timeout?: never } | { abort?: never; timeout?: number }
- * );
- * ```
- *
- * - `abort` and `timeout` are mutually exclusive. The type rejects both, and at runtime passing both fails with a `REQ_OPTIONS_INVALID` fault.
- *
- * - `signal` combines with either one; it is not an alias for `abort`.
- *
- * - `timeout` must be a positive safe integer no greater than `2_147_483_647`. It limits how long opening the session may take and is not applied again on reconnect.
- *
- * - `beforeConnect`, `heartbeat`, `protocols`, and `reconnect` override the client-level options for this call.
- *
- * - When `reconnect` is set, `attempts` defaults to `3` per outage; `0` disables. Successful `open` resets the budget and backoff exponent. Omitting `attempts` does not give unlimited retries within one outage. See {@link withWebSocketReconnect} for validation and final delay caps.
- *
- * See {@link WebSocketHeartbeatConfig}.
+ * `beforeConnect`, `heartbeat`, `protocols`, and `reconnect` override the client-level options for one call. `abort` covers the whole session, including after it opens. There is no startup-only deadline and no `signal` field.
  *
  * @group web-socket
  */
-export type WebSocketExecuteOptions<TIncoming = unknown, TOutgoing = unknown> = UseWebSocketConfig<TIncoming, TOutgoing> & {
-  signal?: AbortSignal;
+export type UseWebSocketConfig<TIncoming = unknown, TOutgoing = unknown> = UseWebSocketBaseConfig<TIncoming, TOutgoing> & {
+  /** Aborts the session, including after it is open. */
+  abort?: AbortSignal;
 };
 /**
- * Executable command created by calling a WebSocketEndpoint.
+ * WebSocket fields read from {@link RequestOptions} for one call.
  *
- * Created by calling a {@link WebSocketEndpoint}. It holds the endpoint definition and the unparsed input. Pass it to `client.execute` to open a session; nothing connects until then.
- *
- * `BaseCommand` carries symbol-keyed members that route the command to the right transport. They are internal, so treat the command as opaque.
+ * See {@link UseWebSocketConfig}. `heartbeat` callbacks are not inferred from the operation; narrow `unknown` messages yourself.
  *
  * @group web-socket
+ * @see {@link WebSocketHeartbeatConfig}
  */
-export interface WebSocketCommand<TInput extends AnyStruct | undefined, TIncoming extends AnyStruct, TOutgoing extends AnyStruct | undefined> extends BaseCommand<typeof WEB_SOCKET_COMMAND> {
-  readonly endpoint: WebSocketDefinition<TInput, TIncoming, TOutgoing>;
-  readonly input: EndpointInput<TInput> | undefined;
-}
+export type WebSocketExecuteOptions<TIncoming = unknown, TOutgoing = unknown> = UseWebSocketConfig<TIncoming, TOutgoing>;
 /**
- * Callable returned by defineWebSocket.
- *
- * Returned by {@link defineWebSocket}. Calling it creates a {@link WebSocketCommand} that you pass to `client.execute`. The call signature depends on `input`:
- *
- * - No `input` declared: `() => WebSocketCommand`.
- *
- * - `input` accepts `undefined`: `(input?: StructInput<TInput>) => WebSocketCommand`.
- *
- * - Otherwise: `(input: StructInput<TInput>) => WebSocketCommand`.
+ * Operation returned by `defineWebSocket`.
  *
- * Calling the endpoint does not connect. The input is parsed when the command is executed.
+ * The first argument is a {@link Client}. Further arguments are the input only. Calling it opens the session and returns the existing error-first tuple.
  *
  * @group web-socket
  */
-export type WebSocketEndpoint<TInput extends AnyStruct | undefined, TIncoming extends AnyStruct, TOutgoing extends AnyStruct | undefined> = EndpointCallable<TInput, WebSocketCommand<TInput, TIncoming, TOutgoing>>;
+export type WebSocketEndpoint<Args extends unknown[], Incoming, Outgoing = never> = (client: Client, ...args: Args) => Promise<SocketAwaitResult<Incoming, Outgoing>>;
 /**
  * Close code and reason recorded when a session is closed with session.close.
  *
@@ -2215,7 +1811,7 @@ export type ManualSocketCloseReason = {
  *
  * - `intervalMs` and `timeoutMs` must be positive, finite, and at most `2_147_483_647`.
  *
- * Set it with {@link withWebSocketHeartbeat} or the `heartbeat` execute option.
+ * Set it with {@link withWebSocketHeartbeat} or the `heartbeat` request option.
  *
  * @group web-socket
  */
@@ -2229,14 +1825,14 @@ export interface WebSocketHeartbeatConfig<TIncoming = unknown, TOutgoing = unkno
  * 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
@@ -2244,23 +1840,7 @@ export interface WebSocketHeartbeatConfig<TIncoming = unknown, TOutgoing = unkno
 export declare function defineWebSocket<const P extends string, TInput extends AnyStruct | undefined = undefined, TIncoming extends AnyStruct = AnyStruct, TOutgoing extends AnyStruct | undefined = undefined>(definition: Omit<WebSocketDefinitionBase<TIncoming, TOutgoing>, "path"> & {
   input?: TInput;
   path: P;
-} & BuilderField<NoInfer<TInput>, WebSocketRequestShape<NoInfer<P>>>): WebSocketEndpoint<TInput, TIncoming, TOutgoing>;
-/**
- * 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
- */
-export declare function executeWebSocketCommand<TInput extends AnyStruct | undefined, TIncoming extends AnyStruct, TOutgoing extends AnyStruct | undefined>(clientConfig: ClientConfig, command: WebSocketCommand<TInput, TIncoming, TOutgoing>, options?: WebSocketExecuteOptions<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>): Promise<SocketAwaitResult<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>>;
+} & BuilderField<NoInfer<TInput>, WebSocketRequestShape<NoInfer<P>>>): WebSocketEndpoint<EndpointArgs<TInput>, WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>;
 /**
  * The outcome of a **single connect attempt**, not the final result of the session.
  *
@@ -2288,8 +1868,8 @@ export type SocketLifecycleOutcome = {
  * Continuation that runs the rest of the HTTP interceptor chain, or the handler.
  *
  * `next(req)` only goes inward: the interceptors registered after this one, then
- * the Fetch handler. It is not a re-dispatch of `client.execute` from the
- * outside of the chain. Call `next` again for a safe
+ * the Fetch handler. It is not a new operation call from outside the chain.
+ * Call `next` again for a safe
  * replay (for example one 401 refresh) from the same interceptor; outer layers
  * do not run a second time. Once the chain has settled, calling `next` rejects
  * with `HTTP interceptor next() cannot be called after the chain has settled`.
@@ -2324,10 +1904,10 @@ interface HttpInterceptor {
  * 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.
@@ -2369,7 +1949,7 @@ type SSEInterceptorFn = (req: HttpRequest, next: SSEHandler) => Promise<EventStr
  *
  * Created by `createSSEInterceptor`. The `kind` tag lets `withInterceptors`
  * accept HTTP, SSE, and WebSocket interceptors in one list; only `kind: 'sse'`
- * interceptors run for SSE commands.
+ * interceptors run for SSE operations.
  *
  * @group interceptors
  */
@@ -2380,12 +1960,12 @@ interface SSEInterceptor {
 /**
  * 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
@@ -2448,7 +2028,7 @@ type WebSocketHandler = (req: HttpRequest) => Promise<WebSocketSessionLike>;
  * {@link WebSocketSessionLike} to short-circuit. Wrap it with
  * `createWebSocketInterceptor` to register it through `withInterceptors`.
  *
- * The chain runs once per `execute`. Reconnects happen inside the session it
+ * The chain runs once per operation. Reconnects happen inside the session it
  * returns and do not run it again.
  *
  * @group interceptors
@@ -2459,7 +2039,7 @@ type WebSocketInterceptorFn = (req: HttpRequest, next: WebSocketHandler) => Prom
  *
  * Created by `createWebSocketInterceptor`. The `kind` tag lets
  * `withInterceptors` accept HTTP, SSE, and WebSocket interceptors in one list;
- * only `kind: 'web-socket'` interceptors run for WebSocket commands.
+ * only `kind: 'web-socket'` interceptors run for WebSocket operations.
  *
  * @group interceptors
  */
@@ -2471,7 +2051,7 @@ interface WebSocketInterceptor {
  * 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.
  *
@@ -2483,7 +2063,7 @@ export declare function createWebSocketInterceptor(fn: WebSocketInterceptorFn):
 /**
  * Any tagged interceptor accepted by client interceptor options.
  *
- * `kind` (`'http'`, `'sse'`, or `'web-socket'`) selects which commands an
+ * `kind` (`'http'`, `'sse'`, or `'web-socket'`) selects which operations an
  * interceptor runs for. `withInterceptors` accepts any mix; each transport runs
  * only its own kind, in registration order.
  *
@@ -2603,7 +2183,7 @@ interface ClientWebSocketOptions {
  * - **onInvalidEvent** — Called when an event has no matching struct and no `default` struct (`'missing-struct'`), or its data fails validation (`'validation-failed'`). The event is skipped. An error thrown by the hook does not close the stream.
  * - **reconnect** — Opt-in. Without it the stream never reconnects. `attempts` defaults to **3** per outage; `attempts: 0` disables retry. A successful handshake resets the budget, callback `attempt`, and backoff exponent. `delayMs` is the first base delay, 1000 by default, and a server-sent `retry:` value replaces it. `factor` defaults to 1. `jitter` is a 0–1 multiplicative factor and defaults to 0. `maxDelayMs` caps the final delay after jitter and rounding; without a configured cap, the platform limit of `2_147_483_647` ms still applies. A zero base stays zero; valid-number overflow saturates at the caps. Without `shouldReconnect` only `GET`, `HEAD`, `OPTIONS`, `PUT`, and `DELETE` reconnect; with it, its result decides for every method and its context carries `method`. A `ReadableStream` request body never reconnects. Reconnect sends the latest ID as UTF-8 bytes in `Last-Event-ID`; an empty ID clears it and an ID containing NUL is ignored.
  *
- * Reconnect options are validated before interceptors or Fetch: `attempts` is 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` is finite and positive; `jitter` is finite and within 0–1. Invalid values return `REQ_OPTIONS_INVALID` at execute time.
+ * Reconnect options are validated before interceptors or Fetch: `attempts` is 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` is finite and positive; `jitter` is finite and within 0–1. Invalid values return `REQ_OPTIONS_INVALID` when the operation runs.
  *
  * Set these with `withSSEHandle`, `withSSEOnInvalidEvent`, and `withSSEReconnect`. Omitting `withSSEReconnect` disables retry.
  *
@@ -2670,7 +2250,7 @@ interface ClientSSEConfig extends ClientSSEOptions {
 interface HttpClientOptions {
   /** Base URL prepended to relative request paths. */
   endpoint: string;
-  /** Static default headers merged under command headers for HTTP/SSE. */
+  /** Static default headers merged under headers returned by the builder for HTTP/SSE. */
   headers?: Headers;
   /** HTTP transport overrides; the default resolves global `fetch` on each call. */
   http?: {
@@ -2680,8 +2260,6 @@ interface HttpClientOptions {
   interceptors?: Interceptor[];
   /** Serializes encoded query objects. Omit to use `URLSearchParams`. */
   querySerializer?: QuerySerializer;
-  /** Default HTTP execute timeout in milliseconds (SSE/WebSocket ignore this). */
-  timeout?: number;
   /** XSRF cookie/header mapping and optional token provider. */
   xsrf?: {
     /** Cookie name that stores the XSRF token. */
@@ -2699,7 +2277,7 @@ interface HttpClientOptions {
 /**
  * Input-shaped client options, including SSE and WebSocket, that mirror what the option helpers configure.
  *
- * The user-facing shape of the settings before defaults are applied. `createClient` does not accept this object; configure a client with option helpers such as `withEndpoint` and `withTimeout`. {@link ClientConfig} is the resolved counterpart. The HTTP members come from the non-exported `HttpClientOptions` base and are shown inline.
+ * The user-facing shape of the settings before defaults are applied. `createClient` does not accept this object; configure a client with option helpers such as `withEndpoint`. {@link ClientConfig} is the resolved counterpart. The HTTP members come from the non-exported `HttpClientOptions` base and are shown inline.
  *
  * @group client
  */
@@ -2713,7 +2291,7 @@ interface ClientOptions extends HttpClientOptions {
 interface HttpClientConfig {
   /** Base URL prepended to relative request paths. */
   endpoint: string;
-  /** Static default headers merged under command headers for HTTP/SSE. */
+  /** Static default headers merged under headers returned by the builder for HTTP/SSE. */
   headers?: Headers;
   /** HTTP transport with a required fetch handle. */
   http: {
@@ -2723,8 +2301,6 @@ interface HttpClientConfig {
   interceptors: Interceptor[];
   /** Serializes encoded query objects. Omit to use `URLSearchParams`. */
   querySerializer?: QuerySerializer;
-  /** Default HTTP execute timeout in milliseconds (SSE/WebSocket ignore this). */
-  timeout?: number;
   /** Resolved XSRF settings when enabled. */
   xsrf?: {
     /** Cookie name that stores the XSRF token. */
@@ -2766,7 +2342,7 @@ type ClientOption = (config: ClientConfig) => void;
 /**
  * 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:`.
+ * 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.
  *
@@ -2789,22 +2365,10 @@ export declare function withEndpoint(endpoint: string): ClientOption;
  * @group client
  */
 export declare function withHeaders(headers: HeadersInit): ClientOption;
-/**
- * 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
- */
-export declare function withTimeout(ms: number): ClientOption;
 /**
  * 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.
+ * 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`.
@@ -2848,7 +2412,7 @@ export declare function withSSEHandle(fetchImpl: FetchHandle): ClientOption;
 /**
  * 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.
+ * 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`.
@@ -2867,7 +2431,7 @@ export declare function withWebSocketHandle(WebSocketImpl: WebSocketHandleConstr
  * - `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.
+ * - 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`.
@@ -2879,7 +2443,7 @@ export declare function withWebSocketBeforeConnect(beforeConnect: ClientWebSocke
  *
  * 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.
+ * 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`.
@@ -2904,8 +2468,8 @@ export declare function withWebSocketProtocols(protocols: readonly string[]): Cl
  * - 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.
+ * - `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`.
@@ -2931,8 +2495,8 @@ export declare function withWebSocketHeartbeat(options: ClientWebSocketOptions["
  * - `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.
+ * - 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`.
@@ -2993,7 +2557,7 @@ export declare function withSSEOnInvalidEvent(handler: ClientSSEOptions["onInval
  * - `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.
+ * - 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`.
@@ -3024,41 +2588,206 @@ export declare function withXSRF(options?: HttpClientOptions["xsrf"]): ClientOpt
  * @group client
  */
 export declare function withCredentials(value: boolean): ClientOption;
+/**
+ * Internal symbol key for a client's base configuration and derived request options.
+ *
+ * Application code calls the client and passes it to an operation. It does not read this property.
+ *
+ * @group client
+ */
 declare const CLIENT: unique symbol;
 /**
- * A client returned by `createClient` holds the resolved {@link ClientConfig} and executes HTTP, SSE, and WebSocket commands.
+ * Flat per-call options. Each protocol reads the fields it understands and ignores the rest.
  *
- * The command type selects the `execute` overload. Failures are returned as faults in the result tuple rather than thrown; the promise rejects only for a value that is not a Defjs command (`Error: Unsupported command`). `[CLIENT]` is an internal symbol key that holds the resolved {@link ClientConfig}; it is not part of the call surface.
+ * SSE reads only `abort` from request options. SSE reconnect comes from client configuration (`withSSEReconnect`), so `client({ reconnect })` affects WebSocket only.
+ *
+ * `abort` cancels HTTP, SSE, and WebSocket calls. `onUploadProgress` and `onDownloadProgress` apply to HTTP. `beforeConnect`, `protocols`, `heartbeat`, and `reconnect` apply to WebSocket and replace the client setting for that call as a whole value. There is no `timeout` or `signal` field. Pass `AbortSignal.timeout(ms)` as `abort` when a call needs a deadline.
  *
  * @group client
- * @see {@link HttpAwaitResult}
- * @see {@link StreamAwaitResult}
- * @see {@link SocketAwaitResult}
- */
-type Client = {
-  /** Internal symbol key for the resolved client configuration. */
-  readonly [CLIENT]: ClientConfig;
-  /** Open an SSE command and return stream open/await results. */
-  execute<TInput extends AnyStruct | undefined, TEvents extends EventStructs, TError extends AnyStruct | undefined = undefined>(command: EventStreamCommand<TInput, TEvents, TError>, options?: EventStreamExecuteOptions): Promise<StreamAwaitResult<EventStreamData<TEvents>, TError>>;
-  /** Open a WebSocket command and return session await results. */
-  execute<TInput extends AnyStruct | undefined, TIncoming extends AnyStruct, TOutgoing extends AnyStruct | undefined>(command: WebSocketCommand<TInput, TIncoming, TOutgoing>, options?: WebSocketExecuteOptions<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>): Promise<SocketAwaitResult<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>>;
-  /** Run an HTTP command and return an await-result tuple. */
-  execute<TInput extends AnyStruct | undefined, TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined>(command: HttpCommand<TInput, TOutput, TError>, options?: HttpExecuteOptions): ReturnType<typeof executeHttpCommand<TInput, TOutput, TError>>;
+ */
+type RequestOptions = {
+  /** Aborts the call. An already aborted signal fails the call before transport. */
+  abort?: AbortSignal;
+  /** Observes HTTP upload progress. */
+  onUploadProgress?: HttpProgressFn;
+  /** Observes HTTP download progress. */
+  onDownloadProgress?: HttpProgressFn;
+  /** Runs before each WebSocket connect attempt for this call. */
+  beforeConnect?: ClientWebSocketOptions["beforeConnect"];
+  /** WebSocket subprotocols for this call. Replaces the client list; it is not appended. */
+  protocols?: readonly string[];
+  /** WebSocket heartbeat for this call. Replaces the client heartbeat as a whole value. */
+  heartbeat?: ClientWebSocketOptions["heartbeat"];
+  /** WebSocket reconnect policy for this call. Replaces the client policy as a whole value. */
+  reconnect?: ClientWebSocketOptions["reconnect"];
 };
+interface ClientState {
+  readonly config: ClientConfig;
+  readonly options: RequestOptions;
+}
+/**
+ * Application client returned by `createClient`.
+ *
+ * Calling it returns a new client. The seven known fields are copied from the argument when `client(options)` is called, a top-level snapshot into a fresh options object overlaid on the current options. A later field wins. A field whose value is `undefined` is treated as not provided and keeps the parent's value. A derived client cannot drop a setting its parent has; to go back to no setting, derive again from the client that did not have it. Nested `heartbeat`, `protocols`, and `reconnect` values are kept by reference, not cloned. WebSocket reads them when the operation runs, copying heartbeat fields and the protocols list at that time, so mutating those objects after deriving can still affect a later call. Applications should treat them as immutable after passing them. The original client is not mutated. `client()`, `client(undefined)`, and `client({})` copy the current options. Deriving a client performs no I/O. A getter that throws does so from the call and is not returned as a fault.
+ *
+ * @group client
+ * @see {@link createClient}
+ * @see {@link RequestOptions}
+ */
+interface Client {
+  /** Returns a new client with `options` overlaid on this client's request options. */
+  (options?: RequestOptions): Client;
+  /** Internal state. Not part of the call surface. */
+  readonly [CLIENT]: ClientState;
+}
 /**
  * Creates a Defjs client 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 client is a function. Call it with {@link RequestOptions} to derive a client for one operation. The seven known fields are copied from that argument into a fresh options object. Nested `heartbeat`, `protocols`, and `reconnect` values are kept by reference. The base configuration is shared by every derived client and is not frozen at runtime. It is fixed by convention: nothing in the library changes it, and applications should not either. A getter that throws escapes the call; it is not converted into a fault.
  *
  * @param options - Client option helpers such as `withEndpoint`.
- * @returns A client that can `execute` HTTP, SSE, and WebSocket commands.
+ * @returns A callable client that carries the resolved base configuration.
  *
  * @group client
  * @see {@link Client}
  * @see {@link ClientOption}
+ * @see {@link RequestOptions}
  * @exampleFile examples/api/create-client.ts#example
  */
 export declare function createClient(...options: ClientOption[]): Client;
+/**
+ * HTTP fields of {@link RequestOptions}: progress callbacks and `abort`.
+ *
+ * `onDownloadProgress` and `onUploadProgress` are {@link HttpProgressFn}
+ * callbacks. They receive an {@link HttpProgressEvent} with `loaded`, `total`,
+ * and `lengthComputable`. Other request fields are ignored by HTTP.
+ *
+ * @group http
+ */
+export type UseRequestConfig = {
+  /** Aborts the call. */
+  abort?: AbortSignal;
+  /** Observes download progress. */
+  onDownloadProgress?: HttpProgressFn;
+  /** Observes upload progress. */
+  onUploadProgress?: HttpProgressFn;
+};
+/**
+ * HTTP fields read from {@link RequestOptions} for one call.
+ *
+ * Progress callbacks and `abort`. There is no `timeout` or `signal`.
+ *
+ * @group http
+ */
+export type HttpExecuteOptions = UseRequestConfig;
+/**
+ * Operation returned by `defineRequest`.
+ *
+ * The first argument is a {@link Client}. Further arguments are the input, and only the input: none when the definition declares no `input`, optional when the input struct accepts `undefined`, and required otherwise. Calling it starts the request and returns the error-first tuple.
+ *
+ * @group http
+ */
+export type RequestEndpoint<Args extends unknown[], Data, ErrorData, Response extends HttpMeta> = (client: Client, ...args: Args) => Promise<[error: null, result: Data, response: Response] | [error: FaultOf<ErrorData>, result: undefined, response: undefined]>;
+type DeclaredBody<TStruct> = [TStruct] extends [undefined] ? undefined : Infer<TStruct>;
+type DeclaredResponse<TStruct> = [TStruct] extends [undefined] ? HttpMeta : DecodedResponse<Infer<TStruct>>;
+/**
+ * Decoded success body for the declared `output` struct, or `undefined` when none is declared.
+ *
+ * @group http
+ */
+export type RequestSuccessData<TOutput extends AnyStruct | undefined> = DeclaredBody<TOutput>;
+/**
+ * Decoded error body for the declared `error` struct, or `undefined` when none is declared.
+ *
+ * @group http
+ */
+export type RequestErrorData<TError extends AnyStruct | undefined> = DeclaredBody<TError>;
+type ResponseDeclaration<TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined> = ([TOutput] extends [undefined] ? {
+  output?: never;
+} : {
+  output: TOutput;
+}) & ([TError] extends [undefined] ? {
+  error?: never;
+} : {
+  error: TError;
+});
+/**
+ * Contract for an HTTP endpoint: method, path, optional input, and the structs that decode its bodies.
+ *
+ * Declaring `input` requires an explicit `builder` to place the parsed value on
+ * the request. `input` only defines the parameters; the builder alone decides
+ * where each value goes. Only definitions without `input` may omit `builder`.
+ * `output` declares the body for a 2xx response, `error` the body for anything
+ * else. Only one of the two ever runs, and omitting one means that body is never
+ * read. `ResponseDeclaration` is an internal helper type: `output` and `error`
+ * are required only when the matching type parameter is a struct. There is no
+ * `responseType`: the struct kind selects how a declared body is read. Pass to
+ * `defineRequest` to get a typed endpoint.
+ *
+ * @group http
+ */
+export type RequestDefinition<TInput extends AnyStruct | undefined = undefined, TOutput extends AnyStruct | undefined = undefined, TError extends AnyStruct | undefined = undefined> = ResponseDeclaration<TOutput, TError> & {
+  builder?: OutboundBuilder;
+  input?: TInput;
+  method: string;
+  operation?: string;
+  path: string;
+};
+/**
+ * Await-result tuple for an HTTP call: success is `[null, data, response]`, and failure is `[fault, undefined, undefined]`.
+ *
+ * `TData` and `TErrorData` are decoded body types. On success the third slot
+ * carries `body` only when `output` was declared. On failure it is `undefined`,
+ * because the fault already holds whatever response metadata existed.
+ *
+ * @group http
+ */
+export type HttpAwaitResult<TData = undefined, TErrorData = undefined> = [error: null, result: TData, response: [TData] extends [undefined] ? HttpMeta : DecodedResponse<TData>] | [error: FaultOf<TErrorData>, result: undefined, response: undefined];
+/**
+ * Declares a typed HTTP request endpoint.
+ *
+ * Pass method, path, an optional input struct, and the single `output` and
+ * `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`
+ * 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`. `ResponseDeclaration` and `BuilderField` are
+ * internal helper types: `output` and `error` are required only when the
+ * matching type parameter is a struct, and `builder` is
+ * `(input: BuilderInput<TInput>) => HttpRequestShape` when `input` is declared.
+ *
+ * `output` is one struct for the 2xx body; `error` is one struct for every
+ * non-2xx body. Neither is keyed by status. A declaration is an assertion:
+ * omitting one means that body is never read.
+ *
+ * @param definition - Request contract (method, path, input, builder, output).
+ * @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:
+ *
+ * @example
+ * ```ts
+ * const getUser = defineRequest({
+ *   method: 'GET',
+ *   path: '/users/:id',
+ *   input: struct.object({ id: struct.number(), verbose: struct.boolean() }),
+ *   builder: (input) => ({ path: { id: input.id }, query: { verbose: input.verbose } }),
+ *   output: struct.object({ id: struct.number(), name: struct.string() }),
+ * })
+ * ```
+ * @group http
+ * @exampleFile examples/api/define-request.ts#example
+ */
+export declare function defineRequest<const M extends string, const P extends string, TInput extends AnyStruct | undefined = undefined, TOutput extends AnyStruct | undefined = undefined, TError extends AnyStruct | undefined = undefined>(definition: ResponseDeclaration<TOutput, TError> & {
+  input?: TInput;
+  method: M;
+  operation?: string;
+  path: P;
+} & BuilderField<NoInfer<TInput>, HttpRequestShape<NoInfer<P>, NoInfer<M>>>): RequestEndpoint<EndpointArgs<TInput>, RequestSuccessData<TOutput>, RequestErrorData<TError>, DeclaredResponse<TOutput>>;
 /**
  * Default HTTP transport: perform `httpRequest` with `fetch` and return an `HttpResponse`.
  *
@@ -3079,7 +2808,7 @@ export declare function fetchHandler(httpRequest: HttpRequest, fetchImpl?: Fetch
 /**
  * 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
@@ -3122,7 +2851,7 @@ type BasicAuthInterceptorOptions = {
  * `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`).
@@ -3144,4 +2873,122 @@ export declare function basicAuthHttpInterceptor(fn: () => BasicCredential, opti
  * @group interceptors
  */
 export declare function basicAuthSSEInterceptor(fn: () => BasicCredential, options?: BasicAuthInterceptorOptions): SSEInterceptor;
-export type { AnyStruct, BasicAuthInterceptorOptions, BuilderInput, Client, ClientConfig, ClientOption, ClientOptions, ClientSSEConfig, ClientSSEOptions, ClientWebSocketOptions, DecodedResponse, ErrorMap, EventStreamCloseInfo, EventStreamFaultCode, EventStreamHandle, EventStreamOpenInfo, EventStreamRequestShape, FetchHandle, FlattenedStructError, FormattedStructError, HttpInterceptor, HttpInterceptorNext, HttpMeta, HttpProgressEvent, HttpProgressFn, HttpRequest, HttpRequestShape, HttpResponse, HttpResponseType, Infer, Interceptor, InterceptorFn, MakeResponseOptions, ObjectStruct, ParseResult, QuerySerializer, SSEHandler, SSEInterceptor, SSEInterceptorFn, STRUCT, Struct, StructInput, StructIssue, StructLike, StructMethods, WebSocketHandle, WebSocketHandleConstructor, WebSocketHandler, WebSocketInterceptor, WebSocketInterceptorFn, WebSocketRequestShape, WebSocketSessionLike };
+/**
+ * Map from SSE event names to the structs that decode their data.
+ *
+ * An event with no `event:` field is named `message`. An event whose name has no own entry uses the `default` struct; with neither, the event is skipped and `onInvalidEvent` is called. Declare the event name `__proto__` with a computed own key.
+ *
+ * A `string` event struct keeps the raw `data` text. Every other kind is JSON text: `JSON.parse`, then the struct. A bare `struct.literal` therefore needs JSON text, not an unquoted token.
+ *
+ * Reconnect lives on the client (`withSSEReconnect`). SSE `jitter` is a **0-1 multiplicative factor**, same as WebSocket.
+ *
+ * @group sse
+ */
+export type EventStructs = {
+  [key: string]: AnyStruct;
+};
+type EventName<TKey extends string | number> = `${TKey}`;
+type KnownEventUnion<TEvents extends EventStructs> = { [K in keyof TEvents & (number | string)]: EventName<K> extends "default" ? never : {
+  data: Infer<TEvents[K]>;
+  event: EventName<K>;
+  id?: string;
+}; }[keyof TEvents & (number | string)];
+type DefaultEventUnion<TEvents extends EventStructs> = "default" extends keyof TEvents ? {
+  data: Infer<TEvents["default"]>;
+  event: string;
+  id?: string;
+} : never;
+/**
+ * Union of parsed SSE events inferred from an EventStructs map.
+ *
+ * For each declared event name except `default`, the union has `{ event: <name>; data: Infer<TEvents[name]>; id?: string }`. When a `default` struct is declared, it adds `{ event: string; data: Infer<TEvents['default']>; id?: string }` for every event name that has no struct of its own. `KnownEventUnion` and `DefaultEventUnion` are internal helper types.
+ *
+ * @group sse
+ */
+export type EventStreamData<TEvents extends EventStructs> = TEvents extends EventStructs ? KnownEventUnion<TEvents> | DefaultEventUnion<TEvents> : never;
+interface EventStreamDefinitionBase<TEvents extends EventStructs = EventStructs> {
+  events: TEvents;
+  maxBufferSize: number;
+  maxQueueSize: number;
+  method?: string;
+  operation?: string;
+  path: string;
+}
+/** Makes `error` required only when an error struct is declared, so omission stays `Fault<undefined>`. */
+type EventStreamErrorField<TError extends AnyStruct | undefined> = [TError] extends [undefined] ? {
+  error?: never;
+} : {
+  error: TError;
+};
+/**
+ * Contract that describes an SSE endpoint for defineEventStream.
+ *
+ * The composed members are:
+ *
+ * - `events`, `maxBufferSize`, and `maxQueueSize` (both limits are required positive safe integers), optional `method`, `operation`, and a required `path`.
+ *
+ * - `error`, required only when `TError` is a struct. It decodes the body of a failed handshake (a non-2xx response). The kind rule is the same as for HTTP: `string` is text, `blob` and `file` are blobs, `arrayBuffer` is bytes, and everything else is JSON.
+ *
+ * - `input` and `builder`. The request shape matches HTTP, including `body`; `GET` and `HEAD` cannot return a body. 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` and `EventStreamErrorField` are internal helper types.
+ *
+ * @group sse
+ */
+export type EventStreamDefinition<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs, TError extends AnyStruct | undefined = undefined> = EventStreamDefinitionBase<TEvents> & EventStreamErrorField<TError> & {
+  builder?: OutboundBuilder;
+  input?: TInput;
+};
+/**
+ * Await-result tuple from opening an SSE stream.
+ *
+ * - On success: `[null, stream, open]`. `open` is the returned connection's first successful handshake snapshot for native Defjs handles or wrappers forwarding the same live `open` object; custom handles or wrappers overriding `open` use their current public `open` even after reconnect, while `stream.open` stays live.
+ *
+ * - On failure: `[fault, undefined, open]`. `open` carries the response snapshot when the failure happened after a response arrived, for example a non-2xx handshake, and is `undefined` otherwise.
+ *
+ * - `TError` is the declared `error` struct. It types the decoded error body on the fault.
+ *
+ * @group sse
+ */
+export type StreamAwaitResult<TEvent, TError extends AnyStruct | undefined = undefined> = [error: null, stream: EventStreamHandle<TEvent>, open: EventStreamOpenInfo] | [error: Fault<TError>, stream: undefined, open: EventStreamOpenInfo | undefined];
+/**
+ * SSE field of {@link RequestOptions}. HTTP progress and WebSocket fields are ignored.
+ *
+ * `abort` covers the whole stream, including after it opens. There is no startup-only deadline.
+ *
+ * @group sse
+ */
+export type EventStreamExecuteOptions = {
+  /** Aborts the stream, including after it is open. */
+  abort?: AbortSignal;
+};
+/**
+ * Operation returned by `defineEventStream`.
+ *
+ * The first argument is a {@link Client}. Further arguments are the input only. Calling it opens the stream and returns the existing error-first tuple.
+ *
+ * @group sse
+ */
+export type EventStreamEndpoint<Args extends unknown[], Event, TError extends AnyStruct | undefined = undefined> = (client: Client, ...args: Args) => Promise<StreamAwaitResult<Event, TError>>;
+/**
+ * Declare a typed Server-Sent Events endpoint.
+ *
+ * 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 operation `(client, ...input) => Promise<error-first tuple>`.
+ *
+ * @group sse
+ * @exampleFile examples/api/define-event-stream.ts#example
+ */
+export declare function defineEventStream<const P extends string, const M extends string = "GET", TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs, TError extends AnyStruct | undefined = undefined>(definition: Omit<EventStreamDefinitionBase<TEvents>, "method" | "path"> & EventStreamErrorField<TError> & {
+  input?: TInput;
+  method?: M;
+  path: P;
+} & BuilderField<NoInfer<TInput>, EventStreamRequestShape<NoInfer<P>, NoInfer<M>>>): EventStreamEndpoint<EndpointArgs<TInput>, EventStreamData<TEvents>, TError>;
+export type { AnyStruct, BasicAuthInterceptorOptions, BuilderInput, Client, ClientConfig, ClientOption, ClientOptions, ClientSSEConfig, ClientSSEOptions, ClientWebSocketOptions, DecodedResponse, ErrorMap, EventStreamCloseInfo, EventStreamFaultCode, EventStreamHandle, EventStreamOpenInfo, EventStreamRequestShape, FetchHandle, FlattenedStructError, FormattedStructError, HttpInterceptor, HttpInterceptorNext, HttpMeta, HttpProgressEvent, HttpProgressFn, HttpRequest, HttpRequestShape, HttpResponse, HttpResponseType, Infer, Interceptor, InterceptorFn, MakeResponseOptions, ObjectStruct, ParseResult, QuerySerializer, RequestOptions, SSEHandler, SSEInterceptor, SSEInterceptorFn, STRUCT, Struct, StructInput, StructIssue, StructLike, StructMethods, WebSocketHandle, WebSocketHandleConstructor, WebSocketHandler, WebSocketInterceptor, WebSocketInterceptorFn, WebSocketRequestShape, WebSocketSessionLike };