@defjs/core 0.4.0-beta.0 → 0.4.0-beta.1

package/index.d.ts

@@ -1,7 +1,8 @@
 //#region src/internal/http_request.d.ts
 /**
  * How the HTTP response body should be parsed before struct validation.
- * Defaults to `'json'` when an output shape is declared.
+ * Chosen from the declared struct kind: string is text, blob and file are blobs,
+ * arrayBuffer is bytes, and every other kind is JSON.
  */
 type HttpResponseType = 'arraybuffer' | 'blob' | 'json' | 'text';
 /**
@@ -20,9 +21,9 @@ type HttpProgressFn = (event: HttpProgressEvent) => Promise<void> | void;
 /**
  * Normalized outgoing HTTP request used by handlers, interceptors, and `fetchHandler`.
  *
- * After `struct.json(...)` (or another body codec) runs during command build, `body` is
- * already the wire value — for JSON that means a **JSON text string**. Sign HMAC / digests
- * against that string (or other final bytes), not the original Struct input object.
+ * After the request builder runs, `body` is already the wire value — for JSON that means a
+ * **JSON text string**. Sign HMAC / digests against that string (or other final bytes), not the
+ * original struct input.
  */
 interface HttpRequest {
   abort?: AbortSignal;
@@ -39,7 +40,18 @@ interface HttpRequest {
   operation?: string;
   queryParams?: URLSearchParams;
   queryString?: string;
-  responseType?: HttpResponseType;
+  /**
+   * Representation for a 2xx body, derived from the endpoint `output` struct kind.
+   * Set only when `output` is declared. Interceptors that short-circuit with `makeResponse`
+   * read this to match the transport. Must not be changed. `undefined` leaves the 2xx body unread.
+   */
+  readonly responseType?: HttpResponseType;
+  /**
+   * Representation for a non-2xx body, derived from the endpoint `error` struct kind.
+   * Set only when `error` is declared. Must not be changed. `undefined` leaves the non-2xx body
+   * unread and does not fall back to `responseType`.
+   */
+  readonly errorResponseType?: HttpResponseType;
   timeout?: number;
   uploadProgress?: HttpProgressFn;
   withCredentials?: boolean;
@@ -55,8 +67,8 @@ interface HttpRequest {
 //#region src/internal/http_response.d.ts
 declare const HTTP_RESPONSE: unique symbol;
 /**
- * Parsed HTTP response wrapper returned by handlers and `executeHttpCommand`.
- * `ok` is true for status codes in the 2xx range; `error` may hold transport or parse failures.
+ * Wire-shape HTTP response returned by transports and accepted by interceptors.
+ * `ok` is true for status codes in the 2xx range. A transport failure is a fault, never a response.
  */
 type HttpResponse<R> = {
   readonly [HTTP_RESPONSE]: true;
@@ -64,9 +76,30 @@ type HttpResponse<R> = {
   readonly status: number;
   readonly statusText: string;
   readonly headers: Headers;
-  readonly body: R | null;
-  readonly error?: unknown;
+  /** Absent when no body was present. JSON `null` stays `null`. */
+  readonly body: R | null | undefined;
+  readonly ok: boolean;
+};
+/**
+ * Response metadata, available whenever a response reached the client.
+ *
+ * Carries no body: a body only exists once a declared struct decoded it.
+ */
+type HttpMeta = {
+  readonly headers: Headers;
   readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+};
+/**
+ * Response whose body decoded successfully against a declared struct.
+ *
+ * Reaching this type is the proof that decoding happened; a failed decode is reported
+ * as a fault carrying `HttpMeta` alone.
+ */
+type DecodedResponse<TBody> = HttpMeta & {
+  readonly body: TBody;
 };
 /**
  * Fields accepted by `makeResponse` when building a synthetic `HttpResponse` (for example in interceptors).
@@ -77,18 +110,23 @@ type MakeResponseOptions<R> = {
   url?: string;
   headers?: Headers;
   body?: R | null;
-  error?: unknown;
   request?: HttpRequest;
 };
 /**
  * Build an `HttpResponse` value without performing a network call.
  * Useful in interceptors that short-circuit `next`, and in tests.
  *
- * @param options - Status, headers, body, optional request to copy headers/url from, and optional error; defaults yield status `0`.
+ * @param options - Status, headers, body, and an optional request to copy headers/url from; defaults yield status `0`.
  * @returns An `HttpResponse` with `ok` derived from the status code.
  */
 export declare function makeResponse<R>(options?: MakeResponseOptions<R>): HttpResponse<R>;
 //#endregion
+//#region src/error/cause.d.ts
+/** Shared cause/message sentinel for aborted requests. */
+export declare const ERR_ABORTED: Error;
+/** Shared cause/message sentinel for timed-out requests. */
+export declare const ERR_TIMEOUT: Error;
+//#endregion
 //#region src/struct/errors.d.ts
 /**
  * Optional callback that rewrites a `StructIssue` message before it is stored.
@@ -131,6 +169,15 @@ export declare class StructError extends Error {
   prettify(): string;
 }
 //#endregion
+//#region src/struct/symbols.d.ts
+/**
+ * Enumerable tag on objects produced while parsing endpoint input.
+ * Response decoding and `struct.parse` leave it unset. Internal to the outbound encoder.
+ *
+ * @internal
+ */
+declare const STRUCT: unique symbol;
+//#endregion
 //#region src/struct/types.d.ts
 type Path = Array<number | string>;
 /**
@@ -164,7 +211,7 @@ type OptionalOutputStruct = {
  */
 interface StructIssue {
   /** Machine-readable failure category. */
-  code: 'custom' | 'invalid_enum' | 'invalid_literal' | 'invalid_type' | 'invalid_union' | 'missing_key';
+  code: 'custom' | 'invalid_enum' | 'invalid_intersection' | 'invalid_literal' | 'invalid_type' | 'invalid_union' | 'missing_key';
   /** Human-readable description of the expected type or value. */
   expected: string;
   /** Final message after optional `ErrorMap` rewriting. */
@@ -204,7 +251,7 @@ interface StructMethods<I, O, OO extends boolean> {
    * @param name - Wire / protocol field name.
    * @returns The same struct branded with the alias.
    */
-  alias(name: string): Struct<I, O, OO>;
+  alias(name: string): this;
   /**
    * Allow `null` in addition to the current input and output types.
    *
@@ -237,6 +284,20 @@ interface StructMethods<I, O, OO extends boolean> {
  */
 type Struct<Input = unknown, Output = Input, OptionalOut extends boolean = false> = StructMethods<Input, Output, OptionalOut> & StructLike<Input, Output, OptionalOut>;
 type PresentValue = NonNullable<unknown>;
+declare const carriedStruct: unique symbol;
+/** Keeps the struct that a nullish modifier wrapped, so builders still see its fields. */
+type CarriedStruct<T> = {
+  readonly [carriedStruct]: T;
+};
+declare const unionStructOptions: unique symbol;
+declare const intersectionStructOptions: unique symbol;
+declare const discriminatedUnionOptions: unique symbol;
+interface PreservedStruct<T, I, O, OO extends boolean> extends Struct<I, O, OO>, CarriedStruct<T> {
+  null(): PreservedStruct<T, I | null, O | null, OO>;
+  nullable(): PreservedStruct<T, I | null, O | null, OO>;
+  nullish(): PreservedStruct<T, I | null | undefined, O | null | undefined, true>;
+  optional(): PreservedStruct<T, I | undefined, O | undefined, true>;
+}
 /**
  * Broad struct constraint for endpoint and client generics.
  *
@@ -291,6 +352,10 @@ interface ArrayStructTypes<S extends StructLike<unknown, unknown, boolean>> exte
 }
 interface ArrayStruct<S extends StructLike<unknown, unknown, boolean>> extends StructMethods<ArrayInput<S>, ArrayOutput<S>, false>, StructLike<ArrayInput<S>, ArrayOutput<S>, false> {
   readonly _struct: ArrayStructTypes<S>;
+  null(): PreservedStruct<ArrayStruct<S>, ArrayInput<S> | null, ArrayOutput<S> | null, false>;
+  nullable(): PreservedStruct<ArrayStruct<S>, ArrayInput<S> | null, ArrayOutput<S> | null, false>;
+  nullish(): PreservedStruct<ArrayStruct<S>, ArrayInput<S> | null | undefined, ArrayOutput<S> | null | undefined, true>;
+  optional(): PreservedStruct<ArrayStruct<S>, ArrayInput<S> | undefined, ArrayOutput<S> | undefined, true>;
 }
 interface ObjectStructTypes<T extends ObjectShape> extends StructTypes<ObjectInput<T>, ObjectOutput<T>, false> {
   input: ObjectInput<T>;
@@ -305,123 +370,202 @@ interface ObjectStructTypes<T extends ObjectShape> extends StructTypes<ObjectInp
  */
 interface ObjectStruct<T extends ObjectShape> extends StructMethods<ObjectInput<T>, ObjectOutput<T>, false>, StructLike<ObjectInput<T>, ObjectOutput<T>, false> {
   readonly _struct: ObjectStructTypes<T>;
+  null(): PreservedStruct<ObjectStruct<T>, ObjectInput<T> | null, ObjectOutput<T> | null, false>;
+  nullable(): PreservedStruct<ObjectStruct<T>, ObjectInput<T> | null, ObjectOutput<T> | null, false>;
+  nullish(): PreservedStruct<ObjectStruct<T>, ObjectInput<T> | null | undefined, ObjectOutput<T> | null | undefined, true>;
+  optional(): PreservedStruct<ObjectStruct<T>, ObjectInput<T> | undefined, ObjectOutput<T> | undefined, true>;
 }
-type RequestBodyCodec = 'arrayBuffer' | 'blob' | 'formData' | 'json' | 'text' | 'urlencoded';
-interface RequestBodyStructTypes<C extends RequestBodyCodec, S extends StructLike<unknown, unknown, boolean>> extends StructTypes<Exclude<StructInput<S>, undefined>, Exclude<StructOutput<S>, undefined>, false> {
-  codec: C;
-  input: Exclude<StructInput<S>, undefined>;
-  optionalOut: undefined;
-  output: Exclude<StructOutput<S>, undefined>;
-}
-interface RequestBodyStruct<C extends RequestBodyCodec, S extends StructLike<unknown, unknown, boolean>> extends StructMethods<Exclude<StructInput<S>, undefined>, Exclude<StructOutput<S>, undefined>, false>, StructLike<Exclude<StructInput<S>, undefined>, Exclude<StructOutput<S>, undefined>, false> {
-  readonly _struct: RequestBodyStructTypes<C, S>;
-}
-type RequestBinaryBodyStruct = Struct<ArrayBuffer, ArrayBuffer> | Struct<Blob, Blob>;
-type RequestBodyShapeStruct = RequestBinaryBodyStruct | RequestBodyStruct<RequestBodyCodec, StructLike<unknown, unknown, boolean>>;
-type RequestShape = {
-  body?: RequestBodyShapeStruct;
-  headers?: ObjectStruct<ObjectShape>;
-  path?: ObjectStruct<ObjectShape>;
-  query?: ObjectStruct<ObjectShape>;
+declare const recordValueStruct: unique symbol;
+declare const tupleItemStructs: unique symbol;
+type RecordInput<S extends StructLike<unknown, unknown, boolean>> = {
+  [key: string]: StructInput<S>;
+};
+type RecordOutput<S extends StructLike<unknown, unknown, boolean>> = {
+  [key: string]: FieldOutput<S>;
 };
-type RequestObjectSectionInput<TKey extends 'headers' | 'path' | 'query', TSection> = TSection extends ObjectStruct<ObjectShape> ? {} extends StructInput<TSection> ? { [K in TKey]?: StructInput<TSection>; } : { [K in TKey]: StructInput<TSection>; } : {};
-type RequestInput<T extends RequestShape> = Simplify<RequestObjectSectionInput<'path', T['path']> & RequestObjectSectionInput<'query', T['query']> & RequestObjectSectionInput<'headers', T['headers']> & (T['body'] extends StructLike<unknown, unknown, boolean> ? {
-  body: StructInput<T['body']>;
-} : {})>;
-type RequestOutput<T extends RequestShape> = Simplify<(T['path'] extends ObjectStruct<ObjectShape> ? {
-  path: StructOutput<T['path']>;
-} : {}) & (T['query'] extends ObjectStruct<ObjectShape> ? {
-  query: StructOutput<T['query']>;
-} : {}) & (T['headers'] extends ObjectStruct<ObjectShape> ? {
-  headers: StructOutput<T['headers']>;
-} : {}) & (T['body'] extends StructLike<unknown, unknown, boolean> ? {
-  body: StructOutput<T['body']>;
-} : {})>;
-interface RequestStructTypes<T extends RequestShape> extends StructTypes<RequestInput<T>, RequestOutput<T>, false> {
-  input: RequestInput<T>;
-  optionalOut: undefined;
-  output: RequestOutput<T>;
-}
 /**
- * Request-section struct produced by `struct.request({ path, query, headers, body })`.
- *
- * Groups path, query, headers, and body contracts used by HTTP/SSE/WebSocket builders.
+ * Value struct carried by `struct.record`.
+ * Tagged parsing stores this struct on the record object itself. `null` and `undefined` are not tagged.
  */
-interface RequestStruct<T extends RequestShape> extends StructMethods<RequestInput<T>, RequestOutput<T>, false>, StructLike<RequestInput<T>, RequestOutput<T>, false> {
-  readonly _struct: RequestStructTypes<T>;
+interface RecordStruct<S extends StructLike<unknown, unknown, boolean>> extends Struct<RecordInput<S>, RecordOutput<S>> {
+  readonly [recordValueStruct]: S;
+  null(): PreservedStruct<RecordStruct<S>, RecordInput<S> | null, RecordOutput<S> | null, false>;
+  nullable(): PreservedStruct<RecordStruct<S>, RecordInput<S> | null, RecordOutput<S> | null, false>;
+  nullish(): PreservedStruct<RecordStruct<S>, RecordInput<S> | null | undefined, RecordOutput<S> | null | undefined, true>;
+  optional(): PreservedStruct<RecordStruct<S>, RecordInput<S> | undefined, RecordOutput<S> | undefined, true>;
 }
-type RecordStruct<S extends StructLike<unknown, unknown, boolean>> = Struct<{
-  [key: string]: StructInput<S>;
-}, {
-  [key: string]: FieldOutput<S>;
-}>;
-type TupleStruct<T extends readonly StructLike<unknown, unknown, boolean>[]> = Struct<TupleInput<T>, TupleOutput<T>>;
-type UnionStruct<T extends readonly StructLike<unknown, unknown, boolean>[]> = Struct<UnionInput<T>, UnionOutput<T>>;
-type DiscriminatedUnionStruct<TOptions extends readonly ObjectStruct<ObjectShape>[]> = Struct<StructInput<TOptions[number]>, StructOutput<TOptions[number]>>;
-//#endregion
-//#region src/internal/request_values.d.ts
-interface RequestBodyOptions {
-  readonly contentType?: string | null;
+/** Item structs carried by `struct.tuple`, so builders tag each position. The tuple itself is not tagged. */
+interface TupleStruct<T extends readonly StructLike<unknown, unknown, boolean>[]> extends Struct<TupleInput<T>, TupleOutput<T>> {
+  readonly [tupleItemStructs]: T;
+  null(): PreservedStruct<TupleStruct<T>, TupleInput<T> | null, TupleOutput<T> | null, false>;
+  nullable(): PreservedStruct<TupleStruct<T>, TupleInput<T> | null, TupleOutput<T> | null, false>;
+  nullish(): PreservedStruct<TupleStruct<T>, TupleInput<T> | null | undefined, TupleOutput<T> | null | undefined, true>;
+  optional(): PreservedStruct<TupleStruct<T>, TupleInput<T> | undefined, TupleOutput<T> | undefined, true>;
+}
+interface UnionStruct<T extends readonly StructLike<unknown, unknown, boolean>[]> extends Struct<UnionInput<T>, UnionOutput<T>> {
+  readonly [unionStructOptions]: T;
+  null(): PreservedStruct<UnionStruct<T>, UnionInput<T> | null, UnionOutput<T> | null, false>;
+  nullable(): PreservedStruct<UnionStruct<T>, UnionInput<T> | null, UnionOutput<T> | null, false>;
+  nullish(): PreservedStruct<UnionStruct<T>, UnionInput<T> | null | undefined, UnionOutput<T> | null | undefined, true>;
+  optional(): PreservedStruct<UnionStruct<T>, UnionInput<T> | undefined, UnionOutput<T> | undefined, true>;
+}
+interface DiscriminatedUnionStruct<TOptions extends readonly ObjectStruct<ObjectShape>[]> extends Struct<StructInput<TOptions[number]>, StructOutput<TOptions[number]>> {
+  readonly [discriminatedUnionOptions]: TOptions;
+  null(): PreservedStruct<DiscriminatedUnionStruct<TOptions>, StructInput<TOptions[number]> | null, StructOutput<TOptions[number]> | null, false>;
+  nullable(): PreservedStruct<DiscriminatedUnionStruct<TOptions>, StructInput<TOptions[number]> | null, StructOutput<TOptions[number]> | null, false>;
+  nullish(): PreservedStruct<DiscriminatedUnionStruct<TOptions>, StructInput<TOptions[number]> | null | undefined, StructOutput<TOptions[number]> | null | undefined, true>;
+  optional(): PreservedStruct<DiscriminatedUnionStruct<TOptions>, StructInput<TOptions[number]> | undefined, StructOutput<TOptions[number]> | undefined, true>;
+}
+interface IntersectionStruct<T extends readonly StructLike<unknown, unknown, boolean>[]> extends Struct<IntersectionInput<T>, IntersectionOutput<T>> {
+  readonly [intersectionStructOptions]: T;
+  null(): PreservedStruct<IntersectionStruct<T>, IntersectionInput<T> | null, IntersectionOutput<T> | null, false>;
+  nullable(): PreservedStruct<IntersectionStruct<T>, IntersectionInput<T> | null, IntersectionOutput<T> | null, false>;
+  nullish(): PreservedStruct<IntersectionStruct<T>, IntersectionInput<T> | null | undefined, IntersectionOutput<T> | null | undefined, true>;
+  optional(): PreservedStruct<IntersectionStruct<T>, IntersectionInput<T> | undefined, IntersectionOutput<T> | undefined, true>;
 }
 //#endregion
-//#region src/internal/request_builder.d.ts
-type RequestTransport = 'http' | 'sse' | 'webSocket';
-declare const BOUND_SOURCE: unique symbol;
-declare const ARRAY_PROJECTION: unique symbol;
-type BuildBoundRef<TOutput = unknown> = {
-  readonly [BOUND_SOURCE]: {
-    readonly output: TOutput;
-  };
-};
-type BuildArrayProjection<TItem> = {
-  readonly [ARRAY_PROJECTION]: never;
-  readonly item: TItem;
-};
-type BuildArray<TItem, TOutput extends readonly unknown[]> = BuildBoundRef<TOutput> & {
-  map<TProjection>(callback: (item: TItem) => TProjection): BuildArrayProjection<TProjection>;
-};
-type BuildInput<T> = T extends {
-  readonly _struct: {
-    readonly output: infer TOutput;
-  };
-} ? BuildOutput<TOutput> : BuildBoundRef;
-type BuildOutput<TOutput> = TOutput extends readonly (infer TItem)[] ? BuildArray<BuildOutput<TItem>, TOutput> : TOutput extends {
-  [key: string]: unknown;
-} ? BuildBoundRef & { readonly [K in keyof TOutput]: BuildOutput<TOutput[K]>; } : BuildBoundRef<TOutput>;
-type BuildFlatScalar = bigint | boolean | Date | null | number | string | undefined;
-type BuildFlatValue = BuildFlatScalar | readonly BuildFlatScalar[];
-type BuildFormDataValue = BuildFlatValue | Blob | File | readonly (Blob | BuildFlatScalar | File)[];
-type BuildJsonProjection = BuildArrayProjection<unknown> | BuildBoundRef | undefined | readonly BuildJsonProjection[] | {
-  readonly [key: string]: BuildJsonProjection;
+//#region src/error/types.d.ts
+/**
+ * Every failure Defjs reports, as one closed set of codes.
+ *
+ * The prefix before the first `_` is the class; there is no separate `kind` field.
+ * Read the prefix for coarse triage and the whole code for an exact case:
+ *
+ * | Class  | Meaning                                                        |
+ * | ------ | -------------------------------------------------------------- |
+ * | `HTTP` | The peer answered with a non-2xx status.                        |
+ * | `REQ`  | The request never left: input, execute 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.                        |
+ * | `CAP`  | A declared buffer or queue limit was exceeded.                  |
+ * | `ENV`  | The host runtime lacks a required capability.                   |
+ *
+ * The set is closed on purpose: it keeps `switch (fault.code)` exhaustive. Extensions
+ * report their own detail through `cause`, not through a new code.
+ */
+export type FaultCode = 'CAP_BUFFER_EXCEEDED' | 'CAP_QUEUE_OVERFLOW' | 'ENV_UNSUPPORTED' | 'EXT_HOOK_FAILED' | 'EXT_INTERCEPTOR_FAILED' | 'EXT_OBSERVER_FAILED' | 'HTTP_STATUS' | 'NET_ABORTED' | 'NET_BODY_INCOMPLETE' | 'NET_TIMEOUT' | 'NET_UNREACHABLE' | 'REQ_BUILD_FAILED' | 'REQ_INPUT_INVALID' | 'REQ_OPTIONS_INVALID' | 'RES_DECODE_FAILED' | 'RES_MEDIA_TYPE_INVALID' | 'RES_STRUCT_MISMATCH';
+/**
+ * The class of a fault code: the segment before its first `_`.
+ *
+ * @typeParam C - A `FaultCode`, or a union of them.
+ */
+export type FaultClass<C extends string> = C extends `${infer TClass}_${string}` ? TClass : never;
+/** Codes whose fault carries response metadata but no body. */
+export type DecodeFaultCode = 'RES_DECODE_FAILED' | 'RES_MEDIA_TYPE_INVALID' | 'RES_STRUCT_MISMATCH';
+/** Codes whose fault may never have reached a response. */
+export type PreflightFaultCode = Exclude<FaultCode, DecodeFaultCode | 'HTTP_STATUS'>;
+type ErrorBody<TErr> = [TErr] extends [undefined] ? undefined : Infer<TErr>;
+/**
+ * `HttpStatusFault` expressed by its decoded body type instead of the struct that produced it.
+ *
+ * Factories work in decoded values, so they use this form; endpoint types use
+ * `HttpStatusFault` and let `Infer` bridge the two.
+ */
+export type HttpStatusFaultOf<TData> = Error & {
+  code: 'HTTP_STATUS';
+  data: TData;
+  response: [TData] extends [undefined] ? HttpMeta : DecodedResponse<TData>;
+  status: number;
 };
-type BuildRecordProjection = {
-  readonly [key: string]: BuildBoundRef<BuildFlatValue> | undefined;
+/**
+ * The peer answered with a non-2xx status and the declared `error` struct decoded its body.
+ *
+ * Omitting `error` skips decoding, which leaves `data` as `undefined` and `response`
+ * without a `body` field.
+ */
+export type HttpStatusFault<TErr extends AnyStruct | undefined = undefined> = HttpStatusFaultOf<ErrorBody<TErr>>;
+/**
+ * A response arrived but could not be read as declared.
+ *
+ * `response` is metadata only: a body is a decoded value, and decoding is what failed.
+ * The offending detail lives on `cause` (a `StructError` for a struct mismatch, the
+ * parser failure for an unreadable representation).
+ */
+export type DecodeFault = Error & {
+  cause: unknown;
+  code: DecodeFaultCode;
+  response: HttpMeta;
+  status: number;
 };
-type BuildFormDataProjection = {
-  readonly [key: string]: BuildBoundRef<BuildFormDataValue> | undefined;
+/**
+ * A failure that may have happened before any response existed.
+ *
+ * `response` is present only where the transport already had metadata to report,
+ * such as a body that truncated mid-download.
+ */
+export type PreflightFault = Error & {
+  cause?: unknown;
+  code: PreflightFaultCode;
+  response?: HttpMeta;
 };
-interface RequestBuilder {
-  addFormData(projection: BuildFormDataProjection): void;
-  addFormUrlEncoded(projection: BuildRecordProjection, options?: RequestBodyOptions): void;
-  addHeaders(projection: BuildRecordProjection): void;
-  setArrayBuffer(value: BuildBoundRef<ArrayBuffer>, options?: RequestBodyOptions): void;
-  setBlob(value: BuildBoundRef<Blob>, options?: RequestBodyOptions): void;
-  setFormData(projection: BuildFormDataProjection): void;
-  setFormUrlEncoded(projection: BuildRecordProjection, options?: RequestBodyOptions): void;
-  setHeaders(projection: BuildRecordProjection): void;
-  setHtml(value: BuildBoundRef<string>, options?: RequestBodyOptions): void;
-  setJson(projection: BuildJsonProjection, options?: RequestBodyOptions): void;
-  setPathParams(projection: BuildRecordProjection): void;
-  setQueryParams(projection: BuildRecordProjection): void;
-  setText(value: BuildBoundRef<string>, options?: RequestBodyOptions): void;
-}
-interface WebSocketRequestBuildContext {
-  setPathParams(projection: BuildRecordProjection): void;
-  setQueryParams(projection: BuildRecordProjection): void;
-}
-type RequestBuildInput<TInput extends AnyStruct | undefined> = [TInput] extends [undefined] ? unknown : TInput extends AnyStruct ? BuildInput<TInput> : never;
-type RequestBuildContext<TTransport extends RequestTransport = 'http'> = TTransport extends 'webSocket' ? WebSocketRequestBuildContext : RequestBuilder;
-type RequestBuildHandler<TInput extends AnyStruct | undefined, TTransport extends RequestTransport = 'http'> = (request: RequestBuildContext<TTransport>, input: RequestBuildInput<TInput>) => void;
+/**
+ * Any failure returned by `client.execute`, expressed by its decoded error-body type.
+ *
+ * @typeParam TData - The decoded `error` body, or `undefined` when no error struct was declared.
+ */
+export type FaultOf<TData = undefined> = DecodeFault | HttpStatusFaultOf<TData> | PreflightFault;
+/**
+ * Any failure returned by `client.execute`, discriminated by `code`.
+ *
+ * @typeParam TErr - The endpoint's declared `error` struct, or `undefined` when it declares none.
+ */
+export type Fault<TErr extends AnyStruct | undefined = undefined> = FaultOf<ErrorBody<TErr>>;
+/**
+ * Any fault at all, whatever its decoded error-body type.
+ *
+ * Use it for handlers that classify faults without caring which endpoint produced them.
+ * Prefer `Fault<typeof yourErrorStruct>` where the body type matters.
+ */
+export type AnyFault = DecodeFault | HttpStatusFaultOf<undefined> | HttpStatusFaultOf<unknown> | PreflightFault;
+//#endregion
+//#region src/error/factory.d.ts
+/**
+ * Build the fault for a non-2xx response whose body decoded against the declared `error` struct.
+ *
+ * @param response - The response, carrying the decoded body.
+ * @returns An `HTTP_STATUS` fault whose `data` is that body.
+ */
+export declare function createHttpStatusFault<TData>(response: DecodedResponse<TData>): HttpStatusFaultOf<TData>;
+/**
+ * Build the fault for a non-2xx response that was never decoded, because the endpoint
+ * declared no `error` struct.
+ *
+ * @param response - Metadata of the response; no body was read.
+ * @returns An `HTTP_STATUS` fault whose `data` is `undefined`.
+ */
+export declare function createUndecodedHttpStatusFault(response: HttpMeta): HttpStatusFaultOf<undefined>;
+/**
+ * Build the fault for a response that arrived but could not be read as declared.
+ *
+ * Carries metadata only: a body is a decoded value, and decoding is what failed.
+ *
+ * @param code - Which read step failed.
+ * @param cause - Underlying parser or struct failure.
+ * @param response - Metadata of the response that could not be read.
+ * @returns A decode fault with no body.
+ */
+export declare function createDecodeFault(code: DecodeFaultCode, cause: unknown, response: HttpMeta): DecodeFault;
+/**
+ * Build a fault for a failure that may have happened before any response existed.
+ *
+ * @param code - The specific failure.
+ * @param cause - Underlying value, when there is one; the code becomes the message otherwise.
+ * @param response - Metadata, only where the transport already had some to report.
+ * @returns A preflight fault.
+ */
+export declare function createPreflightFault(code: PreflightFaultCode, cause?: unknown, response?: HttpMeta): PreflightFault;
+/**
+ * Build a `NET_*` fault, choosing the code from the shape of `cause`.
+ *
+ * Recognizes the shared abort/timeout sentinels and the platform's `AbortError`/`TimeoutError`;
+ * anything else is reported as unreachable.
+ *
+ * @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.
+ */
+export declare function createNetworkFault(cause: unknown, response?: HttpMeta): PreflightFault;
 //#endregion
 //#region src/struct/constructors.d.ts
 declare function createStringStruct(): StringStruct;
@@ -433,13 +577,8 @@ declare function createUnknownStruct(): UnknownStruct;
 declare function createLiteralStruct<const T extends LiteralValue>(value: T): Struct<T, T>;
 declare function createArrayStruct<S extends StructLike<unknown, unknown, boolean>>(item: S): ArrayStruct<S>;
 declare function createObjectStruct<T extends ObjectShape>(shape: T): ObjectStruct<T>;
-declare function createRequestStruct<const T extends RequestShape>(shape: T): RequestStruct<T>;
-declare function createJsonBodyStruct<S extends StructLike<unknown, unknown, boolean>>(struct: S, options?: {
-  contentType?: string | null;
-}): RequestBodyStruct<'json', S>;
-declare function createUrlencodedBodyStruct<T extends ObjectShape>(shape: T): RequestBodyStruct<'urlencoded', ObjectStruct<T>>;
-declare function createFormDataBodyStruct<T extends ObjectShape>(shape: T): RequestBodyStruct<'formData', ObjectStruct<T>>;
-declare function createTextBodyStruct(): RequestBodyStruct<'text', StringStruct>;
+declare function createUrlencodedBodyStruct<T extends ObjectShape>(shape: T): ObjectStruct<T>;
+declare function createFormDataBodyStruct<T extends ObjectShape>(shape: T): ObjectStruct<T>;
 declare function createRecordStruct<S extends StructLike<unknown, unknown, boolean>>(value: S): RecordStruct<S>;
 declare function createTupleStruct<const T extends readonly [StructLike<unknown, unknown, boolean>, ...StructLike<unknown, unknown, boolean>[]]>(items: T): TupleStruct<T>;
 type RequiredDiscriminatorOption<TDiscriminator extends string, TOption extends ObjectStruct<ObjectShape>> = TOption extends ObjectStruct<infer TShape> ? TDiscriminator extends keyof TShape ? TShape[TDiscriminator] extends StructLike<infer TInput, unknown, false> ? undefined extends TInput ? never : null extends TInput ? [TInput] extends [null] ? TOption : never : TOption : never : never : never;
@@ -448,7 +587,7 @@ declare function createDiscriminatedUnionStruct<const TDiscriminator extends str
 declare function createBlobStruct(): Struct<Blob, Blob>;
 declare function createBigIntStruct(): Struct<bigint | string, bigint>;
 declare function createDateStruct(): Struct<Date | number | string, Date>;
-declare function createIntersectionStruct<const T extends readonly [StructLike<unknown, unknown, boolean>, ...StructLike<unknown, unknown, boolean>[]]>(...structs: T): Struct<IntersectionInput<T>, IntersectionOutput<T>>;
+declare function createIntersectionStruct<const T extends readonly [StructLike<unknown, unknown, boolean>, ...StructLike<unknown, unknown, boolean>[]]>(...structs: T): IntersectionStruct<T>;
 declare function createFileStruct(): Struct<File, File>;
 declare function createArrayBufferStruct(): Struct<ArrayBuffer, ArrayBuffer>;
 //#endregion
@@ -471,8 +610,8 @@ declare function structOr<const T extends readonly [StructLike, ...StructLike[]]
  * Facade for building protocol-boundary structs and parsing values.
  *
  * Prefer this entry point over internal constructors. Compose shapes with
- * `struct.object` / `struct.request`, then parse with `struct.parse` or let
- * HTTP/SSE/WebSocket endpoints apply the same contracts at the wire boundary.
+ * `struct.object`, then parse with `struct.parse` or let HTTP/SSE/WebSocket
+ * endpoints apply the same contracts at the wire boundary.
  *
  * @example
  * ```ts
@@ -481,8 +620,12 @@ declare function structOr<const T extends readonly [StructLike, ...StructLike[]]
  *   displayName: struct.string().alias('display_name'),
  * })
  *
- * const getUserInput = struct.request({
- *   path: struct.object({ id: struct.number() }),
+ * const getUser = defineRequest({
+ *   method: 'GET',
+ *   path: '/users/:id',
+ *   input: struct.object({ id: struct.number() }),
+ *   builder: (input) => ({ path: input }),
+ *   output: User,
  * })
  *
  * const [error, user] = struct.parse(User, { id: 1, displayName: 'Ada' })
@@ -501,7 +644,6 @@ export declare const struct: {
   readonly file: typeof createFileStruct;
   readonly formData: typeof createFormDataBodyStruct;
   readonly intersection: typeof createIntersectionStruct;
-  readonly json: typeof createJsonBodyStruct;
   readonly literal: typeof createLiteralStruct;
   readonly null: typeof createNullStruct;
   readonly number: typeof createNumberStruct;
@@ -509,30 +651,12 @@ export declare const struct: {
   readonly or: typeof structOr;
   readonly parse: typeof parseStructTuple;
   readonly record: typeof createRecordStruct;
-  readonly request: typeof createRequestStruct;
   readonly string: typeof createStringStruct;
-  readonly text: typeof createTextBodyStruct;
   readonly tuple: typeof createTupleStruct;
   readonly unknown: typeof createUnknownStruct;
   readonly urlencoded: typeof createUrlencodedBodyStruct;
 };
 //#endregion
-//#region src/http/request.d.ts
-/**
- * One status-to-body mapping used in the array form of `RequestOutputShape`.
- * `status` may be a single code or a list of codes that share the same body struct.
- */
-type ResponseGroupItem<S extends number = number, B extends AnyStruct = AnyStruct> = {
-  body: B;
-  status: S | readonly S[];
-};
-/**
- * Declared HTTP response shapes keyed by status code, as a map or a list of `ResponseGroupItem`s.
- */
-type RequestOutputShape = {
-  [key: number]: AnyStruct;
-} | readonly ResponseGroupItem[];
-//#endregion
 //#region src/sse/transport/parser.d.ts
 /**
  * Portions of this file are adapted from Azure/fetch-event-source.
@@ -550,20 +674,28 @@ interface EventStreamOpenInfo {
   response: HttpResponse<unknown>;
   url: string;
 }
-/** Fatal or recoverable error codes reported when an SSE stream closes with `code: 'error'`. */
-type EventStreamErrorCode = 'INVALID_RESPONSE' | 'MESSAGE_PROCESSING_FAILED' | 'PARSER_LIMIT_EXCEEDED' | 'QUEUE_OVERFLOW' | 'TIMEOUT' | 'TRANSPORT_ERROR';
+/**
+ * Fault codes an event stream can end with, drawn from the one shared `FaultCode` namespace.
+ *
+ * SSE used to carry a parallel set with no mapping to the request error model.
+ */
+type EventStreamFaultCode = Extract<FaultCode, 'CAP_BUFFER_EXCEEDED' | 'CAP_QUEUE_OVERFLOW' | 'EXT_HOOK_FAILED' | 'EXT_OBSERVER_FAILED' | 'NET_TIMEOUT' | 'NET_UNREACHABLE' | 'RES_DECODE_FAILED' | 'RES_MEDIA_TYPE_INVALID'>;
 interface EventStreamCloseInfoBase {
   reason?: string;
   cause?: unknown;
 }
-/** How an SSE stream ended: clean EOF, abort, or an error with `errorCode`. */
+/**
+ * How an SSE stream ended: clean EOF, abort, or an error carrying its fault `code`.
+ *
+ * The discriminant is `kind` so that `code` can mean the same thing it means on a fault.
+ */
 type EventStreamCloseInfo = (EventStreamCloseInfoBase & {
-  code: 'eof';
+  kind: 'eof';
 }) | (EventStreamCloseInfoBase & {
-  code: 'aborted';
+  kind: 'aborted';
 }) | (EventStreamCloseInfoBase & {
-  code: 'error';
-  errorCode: EventStreamErrorCode;
+  code: EventStreamFaultCode;
+  kind: 'error';
 });
 /** Open SSE stream: iterate events, inspect open metadata, and close early. */
 interface EventStreamHandle<TEvent = EventStreamMessage> extends AsyncIterable<TEvent>, AsyncDisposable {
@@ -573,86 +705,6 @@ interface EventStreamHandle<TEvent = EventStreamMessage> extends AsyncIterable<T
   [Symbol.asyncDispose](): PromiseLike<void>;
 }
 //#endregion
-//#region src/error/types.d.ts
-/**
- * Error for an HTTP response whose status is treated as failure.
- */
-export interface HttpStatusError<TErrorData = unknown, TStatus extends number = number> extends Error {
-  code: 'HTTP_STATUS';
-  data: TErrorData;
-  kind: 'http';
-  message: string;
-  response: HttpResponse<unknown>;
-  status: TStatus;
-}
-/**
- * Error for transport-level failures such as abort, timeout, or network issues.
- */
-export interface TransportError extends Error {
-  cause?: unknown;
-  code: 'ABORTED' | 'NETWORK_ERROR' | 'TIMEOUT';
-  kind: 'transport';
-  message: string;
-}
-/**
- * Error for definition-time validation or undeclared response status failures.
- */
-export type DefinitionError = (Error & {
-  cause?: unknown;
-  code: 'REQUEST_VALIDATION_FAILED' | 'RESPONSE_VALIDATION_FAILED' | 'INTERCEPTOR_FAILED';
-  kind: 'definition';
-  response?: HttpResponse<unknown>;
-}) | (Error & {
-  cause?: unknown;
-  code: 'UNDECLARED_STATUS';
-  kind: 'definition';
-  response: HttpResponse<unknown>;
-  status: number;
-});
-/**
- * Union of HTTP status, transport, and definition errors from request execution.
- *
- * @typeParam TErrorData - Declared error body type for `HttpStatusError` variants.
- */
-export type RequestError<TErrorData = unknown> = HttpStatusError<TErrorData> | TransportError | DefinitionError;
-//#endregion
-//#region src/error/factory.d.ts
-/** Shared cause/message sentinel for aborted requests. */
-export declare const ERR_ABORTED: Error;
-/** Shared cause/message sentinel for timed-out requests. */
-export declare const ERR_TIMEOUT: Error;
-/**
- * Build a `TransportError` from an abort, timeout, or other network cause.
- *
- * @param cause - Underlying abort/timeout/error value.
- * @returns A normalized `TransportError`.
- */
-export declare function createTransportError(cause: unknown): TransportError;
-/**
- * Build a `DefinitionError` for request/response validation or undeclared status.
- *
- * @param code - Definition error code.
- * @param cause - Underlying validation or status failure.
- * @param response - HTTP response; required for `UNDECLARED_STATUS` (status is taken from it).
- * @returns A normalized `DefinitionError`.
- */
-export declare function createDefinitionError(code: 'UNDECLARED_STATUS', cause: unknown, response: HttpResponse<unknown>): Extract<DefinitionError, {
-  code: 'UNDECLARED_STATUS';
-}>;
-export declare function createDefinitionError(code: Exclude<DefinitionError['code'], 'UNDECLARED_STATUS'>, cause: unknown, response?: HttpResponse<unknown>): Extract<DefinitionError, {
-  code: Exclude<DefinitionError['code'], 'UNDECLARED_STATUS'>;
-}>;
-/**
- * Build an `HttpStatusError` for a non-success HTTP status.
- *
- * @param status - HTTP status code.
- * @param message - Human-readable error message.
- * @param response - Full HTTP response.
- * @param data - Optional parsed error body.
- * @returns A normalized `HttpStatusError`.
- */
-export declare function createHttpStatusError<TErrorData = unknown, TStatus extends number = number>(status: TStatus, message: string, response: HttpResponse<unknown>, data?: TErrorData): HttpStatusError<TErrorData, TStatus>;
-//#endregion
 //#region src/internal/abort.d.ts
 type UseCancellationConfig = {
   abort?: AbortSignal;
@@ -667,7 +719,67 @@ type EndpointInput<TInput extends AnyStruct | undefined> = TInput extends AnyStr
 //#endregion
 //#region src/internal/endpoint_command.d.ts
 type IsEndpointInputOptional<TInput extends AnyStruct | undefined> = [TInput] extends [undefined] ? true : undefined extends EndpointInput<TInput> ? true : false;
-type EndpointCommandBuilder<TInput extends AnyStruct | undefined, TCommand> = IsEndpointInputOptional<TInput> extends true ? (input?: EndpointInput<TInput>) => TCommand : (input: EndpointInput<TInput>) => TCommand;
+type EndpointCallable<TInput extends AnyStruct | undefined, TCommand> = [TInput] extends [undefined] ? () => TCommand : IsEndpointInputOptional<TInput> extends true ? (input?: EndpointInput<TInput>) => TCommand : (input: EndpointInput<TInput>) => TCommand;
+//#endregion
+//#region src/internal/builder_types.d.ts
+/** Object produced by endpoint input parsing. The symbol points at the struct that produced the node. */
+type Typed = {
+  readonly [STRUCT]: AnyStruct;
+};
+type Scalar = string | number | bigint | boolean | Date;
+type FlatValue = Scalar | readonly Scalar[] | undefined;
+type FlatRecord = {
+  readonly [key: string]: FlatValue;
+};
+type QueryValue = Scalar | readonly QueryValue[] | {
+  readonly [key: string]: QueryValue;
+} | undefined;
+type QueryRecord = {
+  readonly [key: string]: QueryValue;
+};
+type PathParams<P extends string> = P extends `${string}:${infer Name}/${infer Rest}` ? Name | PathParams<`/${Rest}`> : P extends `${string}:${infer Name}` ? Name : never;
+type PathValue<P extends string> = [PathParams<P>] extends [never] ? never : ({ readonly [K in PathParams<P>]: Scalar; } & {
+  readonly [STRUCT]?: never;
+}) | (Typed & {
+  readonly [key: string]: Scalar;
+});
+type HttpRequestShape<P extends string, M extends string> = {
+  body?: Uppercase<M> extends 'GET' | 'HEAD' ? never : unknown;
+  headers?: HeadersInit | FlatRecord;
+  path?: PathValue<P>;
+  query?: URLSearchParams | QueryRecord;
+};
+type WebSocketRequestShape<P extends string> = {
+  body?: never;
+  headers?: never;
+  path?: PathValue<P>;
+  query?: URLSearchParams | QueryRecord;
+};
+type EventStreamRequestShape<P extends string, M extends string> = HttpRequestShape<P, M>;
+type NullishBuilderInput<S, Inner> = null extends Infer<S> ? undefined extends Infer<S> ? BuilderInput<Inner> | null | undefined : BuilderInput<Inner> | null : undefined extends Infer<S> ? BuilderInput<Inner> | undefined : BuilderInput<Inner>;
+type IntersectBuilderInputs<T extends readonly StructLike<unknown, unknown, boolean>[]> = T extends readonly [infer Head extends StructLike<unknown, unknown, boolean>, ...infer Tail extends readonly StructLike<unknown, unknown, boolean>[]] ? BuilderInput<Head> & (Tail['length'] extends 0 ? unknown : IntersectBuilderInputs<Tail>) : unknown;
+/**
+ * Parsed endpoint input seen by a builder.
+ *
+ * Object nodes are intersected with {@link Typed}. Record entries and tuple items are too.
+ * At runtime a record container is also tagged when the parsed value is an object, whether or not it
+ * was merged. Array and tuple containers are not. `null` and `undefined` are never tagged.
+ * Modifiers recover the struct they wrapped. Union options are distributed; intersection options are combined.
+ */
+type BuilderInput<S> = S extends CarriedStruct<infer Inner> ? NullishBuilderInput<S, Inner> : S extends UnionStruct<infer Options> ? BuilderInput<Options[number]> : S extends DiscriminatedUnionStruct<infer Options> ? BuilderInput<Options[number]> : S extends IntersectionStruct<infer Options> ? IntersectBuilderInputs<Options> : S extends RecordStruct<infer Value> ? {
+  [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] ? {
+  builder?: () => TShape;
+} : BuilderInput<TInput> extends TShape ? {
+  builder?: (input: BuilderInput<TInput>) => TShape;
+} : {
+  builder: (input: BuilderInput<TInput>) => TShape;
+};
+//#endregion
+//#region src/internal/outbound_request.d.ts
+/** Accepts any concrete builder. `never` keeps the parameter contravariant. */
+type OutboundBuilder = (input: never) => unknown;
 //#endregion
 //#region src/http/http.d.ts
 /**
@@ -679,11 +791,11 @@ export type UseRequestConfig = {
   onUploadProgress?: HttpProgressFn;
 } & UseCancellationConfig;
 /**
- * Executable HTTP command produced by a `defineRequest` builder.
+ * Executable HTTP command produced by a `defineRequest` endpoint.
  * Carries the request definition and optional typed input for `client.execute`.
  */
-export interface HttpCommand<TInput extends AnyStruct | undefined, TOutput extends RequestOutputShape | undefined> extends BaseCommand<typeof HTTP_COMMAND> {
-  readonly definition: RequestDefinition<TInput, TOutput>;
+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;
 }
 /**
@@ -695,100 +807,84 @@ export type HttpExecuteOptions = UseRequestConfig & {
   signal?: AbortSignal;
 };
 /**
- * Builder returned by `defineRequest`; call with input to create an `HttpCommand`.
+ * Endpoint returned by `defineRequest`; call with input to create an `HttpCommand`.
  */
-export type RequestCommandBuilder<TInput extends AnyStruct | undefined, TOutput extends RequestOutputShape | undefined> = EndpointCommandBuilder<TInput, HttpCommand<TInput, TOutput>>;
-type ResponsePairForStatus<TBody extends AnyStruct, TStatus> = TStatus extends readonly (infer U extends number)[] ? U extends number ? {
-  body: TBody;
-  status: U;
-} : never : TStatus extends number ? {
-  body: TBody;
-  status: TStatus;
-} : never;
-type ResponsePair<TOutput extends RequestOutputShape | undefined> = NonNullable<TOutput> extends readonly (infer TItem)[] ? TItem extends {
-  body: infer TBody extends AnyStruct;
-  status: infer TStatus;
-} ? ResponsePairForStatus<TBody, TStatus> : never : { [K in keyof NonNullable<TOutput>]: NonNullable<TOutput>[K] extends (infer TBody extends AnyStruct) ? K extends number ? {
-  body: TBody;
-  status: K;
-} : K extends `${infer TStatus extends number}` ? {
-  body: TBody;
-  status: TStatus;
-} : never : never; }[keyof NonNullable<TOutput>];
-type HttpStatusErrorByOutput<TOutput extends RequestOutputShape | undefined> = [TOutput] extends [undefined] ? HttpStatusError<undefined> : ResponsePair<TOutput> extends (infer TPair) ? TPair extends {
-  body: infer TBody extends AnyStruct;
-  status: infer TStatus extends number;
-} ? `${TStatus}` extends `2${string}` ? never : HttpStatusError<Infer<TBody>, TStatus> : never : never;
-type RequestErrorByOutput<TOutput extends RequestOutputShape | undefined> = HttpStatusErrorByOutput<TOutput> | TransportError | DefinitionError;
-type ResponseBodyByStatus<TOutput extends RequestOutputShape | undefined, TOk extends boolean> = ResponsePair<TOutput> extends (infer TPair) ? TPair extends {
-  body: infer TBody extends AnyStruct;
-  status: infer TStatus extends number;
-} ? `${TStatus}` extends `2${string}` ? TOk extends true ? TBody : never : TOk extends true ? never : TBody : never : never;
-type InferResponseBodyByStatus<TOutput extends RequestOutputShape | undefined, TOk extends boolean> = [TOutput] extends [undefined] ? undefined : [ResponseBodyByStatus<TOutput, TOk>] extends [never] ? unknown : Infer<ResponseBodyByStatus<TOutput, TOk>>;
-/** Inferred success body type for 2xx statuses declared in `TOutput`. */
-export type RequestSuccessData<TOutput extends RequestOutputShape | undefined> = InferResponseBodyByStatus<TOutput, true>;
-/** Inferred error-body type for non-2xx statuses declared in `TOutput`. */
-export type RequestErrorData<TOutput extends RequestOutputShape | undefined> = InferResponseBodyByStatus<TOutput, false>;
-type ResponseDeclaration<TOutput extends RequestOutputShape | undefined> = [TOutput] extends [undefined] ? {
+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>>;
+/** Inferred success body for the declared `output` struct, or `undefined` when none is declared. */
+export type RequestSuccessData<TOutput extends AnyStruct | undefined> = DeclaredBody<TOutput>;
+/** Inferred error body for the declared `error` struct, or `undefined` when none is declared. */
+export type RequestErrorData<TError extends AnyStruct | undefined> = DeclaredBody<TError>;
+type ResponseDeclaration<TOutput extends AnyStruct | undefined, TError extends AnyStruct | undefined> = ([TOutput] extends [undefined] ? {
   output?: never;
-  responseType?: never;
 } : {
   output: TOutput;
-  responseType?: HttpResponseType;
-};
+}) & ([TError] extends [undefined] ? {
+  error?: never;
+} : {
+  error: TError;
+});
 /**
- * Contract for an HTTP endpoint: method, path, optional input struct, and status-keyed outputs.
- * Pass to `defineRequest` to get a typed command builder.
+ * Contract for an HTTP endpoint: method, path, optional input struct, and the structs that
+ * decode its bodies.
+ *
+ * `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. Pass to `defineRequest`
+ * to get a typed endpoint.
  */
-export type RequestDefinition<TInput extends AnyStruct | undefined = undefined, TOutput extends RequestOutputShape | undefined = undefined> = ResponseDeclaration<TOutput> & {
-  operation?: string;
-} & ({
-  method: string;
-  path: string;
-  build?: never;
+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;
-} | (TInput extends AnyStruct ? {
   method: string;
+  operation?: string;
   path: string;
-  build: RequestBuildHandler<TInput>;
-  input: TInput;
-} : never));
+};
 /**
- * Await-result tuple for an HTTP call: success `[null, body, response]` or failure `[error, undefined, response?]`.
+ * Await-result tuple for an HTTP call.
+ *
+ * Success is `[null, data, response]`; failure is `[fault, undefined, undefined]` because the
+ * fault carries whatever response metadata existed.
  */
-export type HttpAwaitResult<TSuccess = unknown, TErrorData = unknown> = [error: null, result: TSuccess, response: HttpResponse<TSuccess>] | [error: RequestError<TErrorData>, result: undefined, response: HttpResponse<unknown> | undefined];
-type HttpExecuteAwaitResult<TOutput extends RequestOutputShape | undefined> = [error: null, result: RequestSuccessData<TOutput>, response: HttpResponse<RequestSuccessData<TOutput>>] | [error: RequestErrorByOutput<TOutput>, result: undefined, response: HttpResponse<unknown> | undefined];
+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];
 /**
- * Declare a typed HTTP request command builder.
+ * Declare a typed HTTP request endpoint.
  *
- * Pass method, path, optional input struct, and status-keyed output structs.
- * Call the returned builder with input to get an `HttpCommand` for `client.execute`.
+ * 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`.
  *
- * @param definition - Request contract (method, path, input, output).
- * @returns A builder that creates `HttpCommand` values from input.
+ * @param definition - Request contract (method, path, input, builder, output).
+ * @returns An endpoint that creates `HttpCommand` values from input.
  *
  * @example
  * ```ts
  * const getUser = defineRequest({
  *   method: 'GET',
  *   path: '/users/:id',
- *   input: struct.request({ path: struct.object({ id: struct.number() }) }),
- *   output: [{ status: 200, body: struct.object({ id: struct.number(), name: struct.string() }) }],
+ *   input: struct.object({ id: struct.number() }),
+ *   builder: (input) => ({ path: { id: input.id } }),
+ *   output: struct.object({ id: struct.number(), name: struct.string() }),
+ *   error: struct.object({ message: struct.string() }),
  * })
  * ```
  */
-export declare function defineRequest<TInput extends AnyStruct, const TOutput extends RequestOutputShape | undefined = undefined>(definition: RequestDefinition<TInput, TOutput>): RequestCommandBuilder<TInput, TOutput>;
-export declare function defineRequest<TInput extends AnyStruct | undefined = undefined, const TOutput extends RequestOutputShape | undefined = undefined>(definition: RequestDefinition<TInput, TOutput>): RequestCommandBuilder<TInput, TOutput>;
+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>;
 /**
  * Run an `HttpCommand` against client config: validate input, send the request, parse the response.
  * Prefer `client.execute(command)` in application code; this is the underlying implementation.
  *
  * @param clientConfig - Resolved HTTP client configuration (endpoint, interceptors, handler).
- * @param command - Command from a `defineRequest` builder.
+ * @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.
  */
-export declare function executeHttpCommand<TInput extends AnyStruct | undefined, TOutput extends RequestOutputShape | undefined>(clientConfig: HttpClientConfig, command: HttpCommand<TInput, TOutput>, options?: HttpExecuteOptions): Promise<HttpExecuteAwaitResult<TOutput>>;
+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>>;
 //#endregion
 //#region src/sse/sse.d.ts
 /** Map of SSE event names to payload structs. Declare `__proto__` with a computed own key. */
@@ -814,44 +910,43 @@ interface EventStreamDefinitionBase<TEvents extends EventStructs = EventStructs>
   maxQueueSize: number;
   method?: string;
   operation?: string;
-  /** Optional non-2xx handshake bodies; fills `error.data` when the open status is declared. */
-  output?: RequestOutputShape;
   path: string;
 }
-type EventStreamDefinitionWithoutBuild<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs> = EventStreamDefinitionBase<TEvents> & {
-  build?: never;
-  input?: TInput;
-};
-type EventStreamDefinitionWithBuild<TInput extends AnyStruct, TEvents extends EventStructs = EventStructs> = EventStreamDefinitionBase<TEvents> & {
-  build: RequestBuildHandler<TInput, 'sse'>;
-  input: TInput;
+/** 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 describing an SSE endpoint: path, events, and buffer/queue limits. */
-export type EventStreamDefinition<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs> = EventStreamDefinitionWithoutBuild<TInput, TEvents> | (TInput extends AnyStruct ? EventStreamDefinitionWithBuild<TInput, TEvents> : never);
+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`. */
-export type StreamAwaitResult<TEvent> = [error: null, stream: EventStreamHandle<TEvent>, open: EventStreamOpenInfo] | [error: RequestError<unknown>, stream: undefined, open: EventStreamOpenInfo | undefined];
-/** Executable SSE command produced by an `EventStreamCommandBuilder`. */
-export interface EventStreamCommand<TInput extends AnyStruct | undefined, TEvents extends EventStructs> extends BaseCommand<typeof EVENT_STREAM_COMMAND> {
-  readonly endpoint: EventStreamEndpoint<TInput, TEvents>;
+export type StreamAwaitResult<TEvent, TError extends AnyStruct | undefined = undefined> = [error: null, stream: EventStreamHandle<TEvent>, open: EventStreamOpenInfo] | [error: Fault<TError>, stream: undefined, open: EventStreamOpenInfo | undefined];
+/** Executable SSE command produced by an `EventStreamEndpoint`. */
+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-execute options for SSE commands (abort, timeout). */
 export type EventStreamExecuteOptions = UseCancellationConfig & {
   signal?: AbortSignal;
 };
-/** Builder function that creates `EventStreamCommand` values from endpoint input. */
-export type EventStreamCommandBuilder<TInput extends AnyStruct | undefined, TEvents extends EventStructs> = EndpointCommandBuilder<TInput, EventStreamCommand<TInput, TEvents>>;
-type EventStreamEndpoint<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs> = EventStreamDefinition<TInput, TEvents> & {
+/** Endpoint returned by `defineEventStream`; call it to create an `EventStreamCommand`. */
+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 command builder.
+ * Declare a typed Server-Sent Events endpoint.
  *
- * Pass path, event structs, and buffer/queue limits. Call the returned builder
+ * Pass path, event structs, and buffer/queue limits. Call the returned endpoint
  * with input to get an `EventStreamCommand` for `client.execute`.
  *
  * @param definition - SSE contract (path, events, buffer limits, optional input).
- * @returns A builder that creates `EventStreamCommand` values from input.
+ * @returns An endpoint that creates `EventStreamCommand` values from input.
  *
  * @example
  * ```ts
@@ -863,27 +958,34 @@ type EventStreamEndpoint<TInput extends AnyStruct | undefined = undefined, TEven
  * })
  * ```
  */
-export declare function defineEventStream<TInput extends AnyStruct, TEvents extends EventStructs = EventStructs>(definition: EventStreamDefinitionWithBuild<TInput, TEvents>): EventStreamCommandBuilder<TInput, TEvents>;
-export declare function defineEventStream<TInput extends AnyStruct | undefined = undefined, TEvents extends EventStructs = EventStructs>(definition: EventStreamDefinitionWithoutBuild<TInput, TEvents>): EventStreamCommandBuilder<TInput, TEvents>;
+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.
  *
  * @param clientConfig - Resolved client configuration.
- * @param command - SSE command from an `EventStreamCommandBuilder`.
+ * @param command - SSE command from an `EventStreamEndpoint`.
  * @param options - Optional execute options (abort, timeout).
  * @returns Await-result tuple of `[error, stream, open]`.
  */
-export declare function executeEventStreamCommand<TInput extends AnyStruct | undefined, TEvents extends EventStructs>(clientConfig: ClientConfig, command: EventStreamCommand<TInput, TEvents>, options?: EventStreamExecuteOptions): Promise<StreamAwaitResult<EventStreamData<TEvents>>>;
+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>>;
 //#endregion
 //#region src/client/command.d.ts
 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;
 }
 //#endregion
@@ -898,67 +1000,24 @@ interface WebSocketCloseSnapshot {
 //#region src/web_socket/web_socket.d.ts
 /** Lifecycle state of a managed WebSocket session. */
 export type WebSocketState = 'aborted' | 'closed' | 'closing' | 'connecting' | 'error' | 'idle' | 'open' | 'reconnecting';
-/** Map of WebSocket message type names to payload structs. */
-export type SocketStructs = {
-  [key: string]: AnyStruct;
-};
-export interface NormalizedWebSocketIncoming {
-  data: unknown;
-  type: string;
-}
-export type NormalizedWebSocketOutgoing = boolean | null | number | string | readonly unknown[] | {
-  readonly [key: string]: unknown;
-};
-export type WebSocketIncomingNormalizer = (decoded: unknown) => NormalizedWebSocketIncoming | undefined;
-export type WebSocketOutgoingNormalizer = (type: string, encodedPayload: unknown) => NormalizedWebSocketOutgoing;
-type SimplifySocket<T> = { [K in keyof T]: T[K]; } & {};
-type NormalizeSocketMessage<TKey extends string, TPayload> = TPayload extends {
-  [key: string]: unknown;
-} ? SimplifySocket<{
-  type: TKey;
-} & TPayload> : {
-  data: TPayload;
-  type: TKey;
-};
-type SocketSendMessage<TKey extends string, TPayload> = TPayload extends {
-  [key: string]: unknown;
-} ? SimplifySocket<{
-  type: TKey;
-} & TPayload> | {
-  data: TPayload;
-  type: TKey;
-} : {
-  data: TPayload;
-  type: TKey;
-};
-type KnownIncomingSocketUnion<TIncoming extends SocketStructs> = { [K in keyof TIncoming & string as K extends 'default' ? never : K]: NormalizeSocketMessage<K, Infer<TIncoming[K]>>; } extends (infer O) ? O[keyof O] : never;
-type KnownOutgoingSocketUnion<TOutgoing extends SocketStructs> = { [K in keyof TOutgoing & string as K extends 'default' ? never : K]: SocketSendMessage<K, EndpointInput<TOutgoing[K]>>; } extends (infer O) ? O[keyof O] : never;
-type DefaultIncomingSocketUnion<TIncoming extends SocketStructs> = 'default' extends keyof TIncoming ? NormalizeSocketMessage<string, Infer<TIncoming['default']>> : never;
-/** Incoming message shape inferred from an incoming `SocketStructs` map. */
-export type WebSocketIncomingData<TIncoming extends SocketStructs> = [KnownIncomingSocketUnion<TIncoming> | DefaultIncomingSocketUnion<TIncoming>] extends [never] ? never : KnownIncomingSocketUnion<TIncoming> | DefaultIncomingSocketUnion<TIncoming>;
-/** Outgoing message shape inferred from an outgoing `SocketStructs` map. */
-export type WebSocketOutgoingData<TOutgoing extends SocketStructs | undefined> = TOutgoing extends SocketStructs ? [KnownOutgoingSocketUnion<TOutgoing>] extends [never] ? never : KnownOutgoingSocketUnion<TOutgoing> : never;
-interface WebSocketDefinitionBase<TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined> {
+/** Decoded incoming frame. Alias fields use their logical names. */
+export type WebSocketIncomingData<TIncoming extends AnyStruct> = Infer<TIncoming>;
+/** Value accepted by `session.send`. `never` when the endpoint declares no outgoing struct. */
+export type WebSocketOutgoingData<TOutgoing extends AnyStruct | undefined> = TOutgoing extends AnyStruct ? StructInput<TOutgoing> : never;
+interface WebSocketDefinitionBase<TIncoming extends AnyStruct = AnyStruct, TOutgoing extends AnyStruct | undefined = undefined> {
   incoming: TIncoming;
   maxIncomingQueueSize: number;
   maxOutgoingQueueSize?: number;
-  normalizeIncoming?: WebSocketIncomingNormalizer;
-  normalizeOutgoing?: WebSocketOutgoingNormalizer;
   operation?: string;
   outgoing?: TOutgoing;
   path: string;
   protocols?: readonly string[];
 }
-type WebSocketDefinitionWithoutBuild<TInput extends AnyStruct | undefined = undefined, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined> = WebSocketDefinitionBase<TIncoming, TOutgoing> & {
-  build?: never;
+/** Contract describing a WebSocket endpoint: path, message structs, and queue limits. */
+export type WebSocketDefinition<TInput extends AnyStruct | undefined = undefined, TIncoming extends AnyStruct = AnyStruct, TOutgoing extends AnyStruct | undefined = undefined> = WebSocketDefinitionBase<TIncoming, TOutgoing> & {
+  builder?: OutboundBuilder;
   input?: TInput;
 };
-type WebSocketDefinitionWithBuild<TInput extends AnyStruct, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined> = WebSocketDefinitionBase<TIncoming, TOutgoing> & {
-  build: RequestBuildHandler<TInput, 'webSocket'>;
-  input: TInput;
-};
-/** Contract describing a WebSocket endpoint: path, message structs, and queue limits. */
-export type WebSocketDefinition<TInput extends AnyStruct | undefined = undefined, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined> = WebSocketDefinitionWithoutBuild<TInput, TIncoming, TOutgoing> | (TInput extends AnyStruct ? WebSocketDefinitionWithBuild<TInput, TIncoming, TOutgoing> : never);
 /** Connection metadata for the current WebSocket generation. */
 export interface WebSocketConnectionInfo {
   extensions?: string;
@@ -999,7 +1058,7 @@ export interface WebSocketSession<TIncoming = unknown, TOutgoing = never> extend
   send(message: TOutgoing): void;
 }
 /** Await-result tuple from opening a WebSocket via `client.execute`. */
-export type SocketAwaitResult<TIncoming, TOutgoing = never> = [error: null, socket: WebSocketSession<TIncoming, TOutgoing>, connection: WebSocketConnectionInfo] | [error: RequestError<unknown>, socket: undefined, connection: WebSocketConnectionInfo | undefined];
+export type SocketAwaitResult<TIncoming, TOutgoing = never> = [error: null, socket: WebSocketSession<TIncoming, TOutgoing>, connection: WebSocketConnectionInfo] | [error: Fault<undefined>, socket: undefined, connection: WebSocketConnectionInfo | undefined];
 interface UseWebSocketBaseConfig<TIncoming = unknown, TOutgoing = unknown> {
   beforeConnect?: ClientWebSocketOptions['beforeConnect'];
   heartbeat?: WebSocketHeartbeatConfig<TIncoming, TOutgoing>;
@@ -1012,14 +1071,13 @@ export type UseWebSocketConfig<TIncoming = unknown, TOutgoing = unknown> = UseWe
 export type WebSocketExecuteOptions<TIncoming = unknown, TOutgoing = unknown> = UseWebSocketConfig<TIncoming, TOutgoing> & {
   signal?: AbortSignal;
 };
-/** Executable WebSocket command produced by a `WebSocketCommandBuilder`. */
-export interface WebSocketCommand<TInput extends AnyStruct | undefined, TIncoming extends SocketStructs, TOutgoing extends SocketStructs | undefined> extends BaseCommand<typeof WEB_SOCKET_COMMAND> {
-  readonly endpoint: WebSocketEndpoint<TInput, TIncoming, TOutgoing>;
+/** Executable WebSocket command produced by a `WebSocketEndpoint`. */
+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;
 }
-/** Builder function that creates `WebSocketCommand` values from endpoint input. */
-export type WebSocketCommandBuilder<TInput extends AnyStruct | undefined, TIncoming extends SocketStructs, TOutgoing extends SocketStructs | undefined> = EndpointCommandBuilder<TInput, WebSocketCommand<TInput, TIncoming, TOutgoing>>;
-type WebSocketEndpoint<TInput extends AnyStruct | undefined = undefined, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined> = WebSocketDefinition<TInput, TIncoming, TOutgoing>;
+/** Endpoint returned by `defineWebSocket`; call it to create a `WebSocketCommand`. */
+export type WebSocketEndpoint<TInput extends AnyStruct | undefined, TIncoming extends AnyStruct, TOutgoing extends AnyStruct | undefined> = EndpointCallable<TInput, WebSocketCommand<TInput, TIncoming, TOutgoing>>;
 /** Reason recorded when the session is closed via `session.close()`. */
 export type ManualSocketCloseReason = {
   code?: number;
@@ -1030,41 +1088,43 @@ export type ManualSocketCloseReason = {
 export interface WebSocketHeartbeatConfig<TIncoming = unknown, TOutgoing = unknown> {
   intervalMs: number;
   isAck?: (message: TIncoming) => boolean;
-  message?: <T = TOutgoing>() => T | unknown;
+  message?: () => TOutgoing;
   timeoutMs?: number;
 }
 /**
- * Declare a typed WebSocket command builder.
+ * Declare a typed WebSocket endpoint.
  *
  * Pass path, incoming (and optional outgoing) message structs, and queue limits.
- * Call the returned builder with input to get a `WebSocketCommand` for `client.execute`.
+ * Call the returned endpoint with input to get a `WebSocketCommand` for `client.execute`.
  *
  * @param definition - WebSocket contract (path, structs, queue limits, optional input).
- * @returns A builder that creates `WebSocketCommand` values from input.
+ * @returns An endpoint that creates `WebSocketCommand` values from input.
  *
  * @example
  * ```ts
  * const useChat = defineWebSocket({
  *   maxIncomingQueueSize: 16,
  *   path: '/ws/chat',
- *   incoming: { message: struct.object({ text: struct.string() }) },
- *   outgoing: { message: struct.object({ text: struct.string() }) },
+ *   incoming: struct.object({ text: struct.string(), type: struct.literal('message') }),
+ *   outgoing: struct.object({ text: struct.string(), type: struct.literal('message') }),
  * })
  * ```
  */
-export declare function defineWebSocket<TInput extends AnyStruct, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined>(definition: WebSocketDefinitionWithBuild<TInput, TIncoming, TOutgoing>): WebSocketCommandBuilder<TInput, TIncoming, TOutgoing>;
-export declare function defineWebSocket<TInput extends AnyStruct | undefined = undefined, TIncoming extends SocketStructs = SocketStructs, TOutgoing extends SocketStructs | undefined = undefined>(definition: WebSocketDefinitionWithoutBuild<TInput, TIncoming, TOutgoing>): WebSocketCommandBuilder<TInput, TIncoming, TOutgoing>;
+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.
  *
  * @param clientConfig - Resolved client configuration.
- * @param command - WebSocket command from a `WebSocketCommandBuilder`.
+ * @param command - WebSocket command from a `WebSocketEndpoint`.
  * @param options - Optional execute options (heartbeat, reconnect, abort).
  * @returns Await-result tuple of `[error, socket, connection]`.
  */
-export declare function executeWebSocketCommand<TInput extends AnyStruct | undefined, TIncoming extends SocketStructs, TOutgoing extends SocketStructs | undefined>(clientConfig: ClientConfig, command: WebSocketCommand<TInput, TIncoming, TOutgoing>, options?: WebSocketExecuteOptions<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>): Promise<SocketAwaitResult<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>>;
+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>>>;
 /** Outcome of a single WebSocket connect attempt used by reconnect logic. */
 export type SocketLifecycleOutcome = {
   closeInfo: WebSocketCloseSnapshot;
@@ -1175,13 +1235,16 @@ type Interceptor = HttpInterceptor | SSEInterceptor | WebSocketInterceptor;
 //#endregion
 //#region src/client/config.d.ts
 /**
- * Serializes query parameters for the request URL.
+ * Serializes an encoded query object into a query string.
+ *
+ * `query` is the wire object: aliases already applied, `Date` values already ISO
+ * strings, `bigint` values already strings. Nested objects and arrays are preserved.
+ * The returned string is used verbatim and is not passed through `URLSearchParams`.
  *
- * @param params - Normalized `URLSearchParams` built from the request.
- * @param rawParams - Optional original param object before normalization.
- * @returns The query string (without a leading `?`).
+ * @param query - Encoded query object.
+ * @returns The query string without a leading `?`.
  */
-type QueryParamsSerializer = (params: URLSearchParams, rawParams?: {
+type QuerySerializer = (query: {
   [key: string]: unknown;
 }) => string;
 /**
@@ -1247,14 +1310,6 @@ interface ClientWebSocketOptions {
       wasClean?: boolean;
     }) => boolean;
   };
-  /** Called when an incoming message has no matching struct (unknown `type`). Struct/JSON failures still use `onRuntimeError`. */
-  onInvalidEvent?: (context: {
-    reason: 'missing-struct';
-    message: {
-      type: string;
-      data: unknown;
-    };
-  }) => unknown;
 }
 /** Optional SSE settings applied when creating a client. */
 interface ClientSSEOptions {
@@ -1316,8 +1371,8 @@ interface HttpClientOptions {
   };
   /** Interceptors applied in registration order. */
   interceptors?: Interceptor[];
-  /** Custom query-string serializer. */
-  queryParamsSerializer?: QueryParamsSerializer;
+  /** 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. */
@@ -1353,8 +1408,8 @@ interface HttpClientConfig {
   };
   /** Interceptors applied in registration order. */
   interceptors: Interceptor[];
-  /** Query-string serializer used for requests. */
-  queryParamsSerializer: QueryParamsSerializer;
+  /** 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. */
@@ -1392,7 +1447,7 @@ export declare function withEndpoint(endpoint: string): ClientOption;
 /**
  * Sets static default headers for HTTP/SSE requests built by this client.
  *
- * Command `struct.request({ headers })` values override the same names. HMAC and
+ * Builder `headers` override the same names. HMAC and
  * dynamic Bearer tokens still belong in interceptors (they need the serialized body
  * or a refreshed credential).
  *
@@ -1420,12 +1475,16 @@ export declare function withTimeout(ms: number): ClientOption;
  */
 export declare function withInterceptors(...interceptors: Interceptor[]): ClientOption;
 /**
- * Replaces the serializer used when encoding query parameters.
+ * Sets the query serializer for HTTP, SSE, and WebSocket requests.
+ *
+ * The function receives the encoded wire object and its string is used verbatim.
+ * Without this option, queries use `URLSearchParams`: arrays repeat keys and a nested
+ * object fails. A builder that returns `URLSearchParams` skips this serializer.
  *
- * @param serializer - Function that turns params into a query string.
- * @returns An option that sets `config.queryParamsSerializer`.
+ * @param serializer - Function that turns an encoded query object into a string.
+ * @returns An option that sets `config.querySerializer`.
  */
-export declare function withQueryParamsSerializer(serializer: QueryParamsSerializer): ClientOption;
+export declare function withQuerySerializer(serializer: QuerySerializer): ClientOption;
 /**
  * Overrides the Fetch-compatible function used for HTTP requests.
  *
@@ -1482,16 +1541,6 @@ export declare function withWebSocketHeartbeat(options: ClientWebSocketOptions['
  * @returns An option that sets `config.webSocket.reconnect`.
  */
 export declare function withWebSocketReconnect(options: ClientWebSocketOptions['reconnect']): ClientOption;
-/**
- * Handles WebSocket messages whose `type` has no matching incoming struct.
- *
- * JSON/Struct decode failures still go to `session.onRuntimeError`. Unknown types
- * do not tear down the session.
- *
- * @param handler - Observer callback; failures are isolated.
- * @returns An option that sets `config.webSocket.onInvalidEvent`.
- */
-export declare function withWebSocketOnInvalidEvent(handler: ClientWebSocketOptions['onInvalidEvent']): ClientOption;
 /**
  * Handles SSE events that lack a matching struct or fail validation.
  *
@@ -1531,11 +1580,11 @@ declare const CLIENT: unique symbol;
 type Client = {
   readonly [CLIENT]: ClientConfig;
   /** Open an SSE command and return stream open/await results. */
-  execute<TInput extends AnyStruct | undefined, TEvents extends EventStructs>(command: EventStreamCommand<TInput, TEvents>, options?: EventStreamExecuteOptions): Promise<StreamAwaitResult<EventStreamData<TEvents>>>;
+  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 SocketStructs, TOutgoing extends SocketStructs | undefined>(command: WebSocketCommand<TInput, TIncoming, TOutgoing>, options?: WebSocketExecuteOptions<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>): Promise<SocketAwaitResult<WebSocketIncomingData<TIncoming>, WebSocketOutgoingData<TOutgoing>>>;
+  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 RequestOutputShape | undefined>(command: HttpCommand<TInput, TOutput>, options?: HttpExecuteOptions): ReturnType<typeof executeHttpCommand<TInput, TOutput>>;
+  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>>;
 };
 /**
  * Create a Defjs client from option helpers.
@@ -1559,8 +1608,11 @@ export declare function createClient(...options: ClientOption[]): Client;
  * Used by the client unless `withHTTPHandle` replaces it; also usable in tests and custom handlers.
  *
  * @param httpRequest - Normalized request (URL, headers, body, abort, progress hooks).
- * @param fetchImpl - Fetch implementation; defaults to global `fetch`.
- * @returns Parsed `HttpResponse`, or a status-0 response when the network/abort fails.
+ * @param fetchImpl - Fetch implementation; defaults to global `fetch`. The library default handle is called as
+ *   `(url, init)` 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.
+ * @returns Parsed `HttpResponse`. Rejects when no response reached the client, or when reading the
+ *   body failed — a transport failure is a fault, never a response.
  */
 export declare function fetchHandler(httpRequest: HttpRequest, fetchImpl?: FetchHandle): Promise<HttpResponse<unknown>>;
 //#endregion
@@ -1595,4 +1647,4 @@ export declare function basicAuthHttpInterceptor(fn: () => BasicCredential, opti
  */
 export declare function basicAuthSSEInterceptor(fn: () => BasicCredential, options?: BasicAuthInterceptorOptions): SSEInterceptor;
 //#endregion
-export type { AnyStruct, BasicAuthInterceptorOptions, Client, ClientConfig, ClientOption, ClientOptions, ClientSSEConfig, ClientSSEOptions, ClientWebSocketOptions, ErrorMap, EventStreamCloseInfo, EventStreamErrorCode, EventStreamHandle, EventStreamOpenInfo, FetchHandle, FlattenedStructError, FormattedStructError, HttpInterceptor, HttpInterceptorNext, HttpProgressEvent, HttpProgressFn, HttpRequest, HttpResponse, HttpResponseType, Infer, Interceptor, InterceptorFn, MakeResponseOptions, ObjectStruct, ParseResult, QueryParamsSerializer, RequestOutputShape, RequestStruct, ResponseGroupItem, SSEHandler, SSEInterceptor, SSEInterceptorFn, Struct, StructInput, StructIssue, StructLike, StructMethods, WebSocketHandle, WebSocketHandleConstructor, WebSocketHandler, WebSocketInterceptor, WebSocketInterceptorFn, WebSocketSessionLike };
+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 };