@ayepi/core 0.1.0

package/dist/errors.d.cts

@@ -0,0 +1,1729 @@
+import { a as Simplify, i as MaybePromise, n as Get, o as UnionToIntersection, r as Json, t as EmptyObject } from "./types.cjs";
+import { z } from "zod";
+
+//#region src/manifest.d.ts
+
+/**
+ * # Manifest
+ *
+ * The **zod-free runtime configuration** the client needs. It carries exactly
+ * enough structure (per-endpoint key tables, method, path, streaming flags) for
+ * the client to split a single `data` payload back into path/query/body/files
+ * and pick a transport — with no zod schemas, so the frontend bundle stays
+ * schema-free. Obtain it from `app.manifest()` or {@link manifestFromSpec}.
+ *
+ * Every field here is part of the **frozen v0 wire contract**.
+ *
+ * @module
+ */
+/** The HTTP methods ayepi endpoints may use. */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * Runtime description of a single endpoint — everything the client must know to
+ * build a request and interpret a response without access to the zod schemas.
+ */
+interface ManifestEndpoint {
+  /** HTTP method (default `POST`). */
+  readonly method: HttpMethod;
+  /** Path pattern with `:key` segments, e.g. `/users/:id`. */
+  readonly path: string;
+  /** Explicit WebSocket id, or `null` to address the endpoint by `method + path`. */
+  readonly ws: string | null;
+  /** When `true`, the endpoint cannot be called over ws (raw streams / files). */
+  readonly httpOnly: boolean;
+  /** Content-type of the streamed request body (raw, or NDJSON for item streams); `null` if none. */
+  readonly streamIn: string | null;
+  /** `true` when `streamIn` is a typed NDJSON item stream (vs a raw byte stream). */
+  readonly itemsIn: boolean;
+  /** Content-type of the streamed response (raw, or NDJSON/SSE for item streams); `null` if none. */
+  readonly streamOut: string | null;
+  /** `true` when `streamOut` is a typed item stream (vs a raw byte stream). */
+  readonly items: boolean;
+  /** Path-param keys, in path order. */
+  readonly p: readonly string[];
+  /** Query-param keys. */
+  readonly q: readonly string[];
+  /** Body keys, `'raw'` when the body is the entire data payload, or `null` when there is no body. */
+  readonly b: readonly string[] | 'raw' | null;
+  /** Multipart file-field keys. */
+  readonly f: readonly string[];
+  /** Whether the endpoint declares a body at all. */
+  readonly hasBody: boolean;
+  /** Whether the endpoint declares typed request headers. */
+  readonly hasHeaders: boolean;
+  /** When `true`, `call()` resolves a `{ status, data }` discriminated union. */
+  readonly multi: boolean;
+  /** Body wire encoding, or `null` when there is no body. */
+  readonly bodyEnc: 'json' | 'urlencoded' | null;
+}
+/** Runtime description of a single server-pushed event channel. */
+interface ManifestEvent {
+  /** WebSocket channel id. */
+  readonly ws: string;
+  /** Whether the channel is parameterized (subscriptions are keyed by params). */
+  readonly hasParams: boolean;
+}
+/**
+ * The complete zod-free runtime manifest consumed by {@link client} — obtained
+ * from `app.manifest()` or {@link manifestFromSpec}. Hand a client this manifest
+ * (instead of the spec) to talk to a server without shipping its schema code.
+ */
+interface Manifest {
+  readonly endpoints: Readonly<Record<string, ManifestEndpoint>>;
+  readonly events: Readonly<Record<string, ManifestEvent>>;
+}
+//#endregion
+//#region src/path.d.ts
+/**
+ * A single path segment: either a string literal or a named parameter.
+ *
+ * The whole path-matching machinery operates on arrays of these, which is why
+ * no part of it needs regex or `String.replace` over user input.
+ */
+type PathPart = {
+  readonly t: 'lit';
+  readonly v: string;
+} | {
+  readonly t: 'param';
+  readonly k: string;
+};
+/**
+ * The erased (non-generic) shape of a {@link PathTemplate}. Used wherever a
+ * template is accepted without caring about its specific param types.
+ */
+interface AnyPathTemplate {
+  readonly kind: 'path';
+  /** Segment array — never matched or built via string replacement. */
+  readonly parts: readonly PathPart[];
+  /** Display/wire form, derived from {@link parts} (e.g. `/users/:id`). */
+  readonly pattern: string;
+  /** Declared param keys, in path order. */
+  readonly keys: readonly string[];
+  /** Per-key zod schemas; each must accept string input. */
+  readonly schemas: Readonly<Record<string, z.ZodType>>;
+}
+/**
+ * A typed path template produced by the {@link path} tag. Carries its pattern
+ * and per-segment schemas, and can build a URL path from typed params or parse
+ * one back into typed params.
+ *
+ * @typeParam PS - a `{ key: ZodType }` record describing each param segment.
+ */
+interface PathTemplate<PS extends object> extends AnyPathTemplate {
+  /** @internal phantom carrier for the param-schema record */
+  readonly __ps: PS;
+  /**
+   * Build a concrete path from typed params; each value is validated against its
+   * segment schema and encoded per-segment.
+   */
+  build(params: { -readonly [K in keyof PS]: PS[K] extends z.ZodType ? z.input<PS[K]> : never }): string;
+  /**
+   * Parse a concrete path back into typed, coerced params, or `null` when the
+   * path does not match this template.
+   */
+  parse(input: string): { -readonly [K in keyof PS]: PS[K] extends z.ZodType ? z.output<PS[K]> : never } | null;
+}
+/**
+ * Split a spec-author `:key` pattern string into {@link PathPart}s.
+ *
+ * The input is author-controlled (not user input), so a plain `split('/')` is
+ * appropriate here. The leading empty segment from a leading `/` is dropped.
+ */
+declare function splitPattern(pattern: string): PathPart[];
+/** Render {@link PathPart}s back into a `:key` pattern string (the inverse of {@link splitPattern}). */
+declare function joinPattern(parts: readonly PathPart[]): string;
+/**
+ * Match a concrete pathname against {@link PathPart}s.
+ *
+ * Walks segment by segment: literals must equal, params must be non-empty and
+ * are individually `decodeURIComponent`-decoded. Returns the raw (decoded but
+ * un-coerced) param map, or `null` on any mismatch (literal differs, length
+ * differs, or an empty param segment).
+ */
+declare function matchParts(parts: readonly PathPart[], pathname: string): Record<string, string> | null;
+/**
+ * Build a concrete pathname from {@link PathPart}s and a value map. Each param
+ * value is stringified and `encodeURIComponent`-encoded per-segment.
+ *
+ * @throws if a declared param has no value.
+ */
+declare function buildParts(parts: readonly PathPart[], values: Record<string, unknown>): string;
+/** Extract the param keys (in order) from {@link PathPart}s. */
+
+/** One interpolation of the {@link path} tag: a single `{ name: schema }` record. */
+type PathSeg = Readonly<Record<string, z.ZodType>>;
+/** Merge every interpolation's `{ key: schema }` record into one param-schema record. */
+type MergeSegs<P extends readonly PathSeg[]> = [P[number]] extends [never] ? EmptyObject : Simplify<UnionToIntersection<P[number]>>;
+/**
+ * Compile-time guard: every interpolated schema must accept **string** input
+ * (path segments arrive as strings). `z.number()` is rejected; `z.coerce.number()`
+ * is accepted because its input type widens to include strings.
+ */
+type CheckTplParts<P extends readonly PathSeg[]> = { [I in keyof P]: { [K in keyof P[I]]: string extends z.input<P[I][K] & z.ZodType> ? P[I][K] : readonly ['path param schema must accept string input:', K] } };
+/**
+ * Tagged template for typed paths. Each interpolation is a single
+ * `{ name: schema }` object; the schema both **declares** and **types** that
+ * param and must accept string input.
+ *
+ * @example
+ * ```ts
+ * const userPost = path`/users/${{ id: z.uuid() }}/posts/${{ slug: z.string() }}`
+ * userPost.pattern                     // '/users/:id/posts/:slug'
+ * userPost.build({ id, slug })         // '/users/3f…/posts/intro'
+ * userPost.parse('/users/3f…/posts/intro') // { id, slug } | null
+ *
+ * path`/x/${{ n: z.number() }}`        // ❌ compile error: schema must accept string input
+ * path`/x/${{ n: z.coerce.number() }}` // ✅ ok: coerces from string
+ * ```
+ *
+ * @throws at definition time if a param does not occupy a whole segment, an
+ * interpolation is not a single-key object, or a key is declared twice.
+ */
+declare function path<const P extends readonly PathSeg[]>(strings: TemplateStringsArray, ...interpolations: P & CheckTplParts<P>): PathTemplate<MergeSegs<P>>;
+//#endregion
+//#region src/broker.d.ts
+/**
+ * # Broker
+ *
+ * Cross-instance event fanout. Every {@link Server.emit} publishes to the broker;
+ * every server instance subscribes and delivers to its own local WebSocket
+ * connections — so an `emit` on one pod reaches subscribers on **all** pods.
+ *
+ * The message is an opaque string on purpose: the same interface carries any
+ * cross-server transport (Redis pub/sub, NATS, Postgres `LISTEN/NOTIFY`, …).
+ *
+ * @module
+ */
+/**
+ * Pluggable message bus for event fanout across server instances.
+ *
+ * A conforming implementation needs only two operations: publish an opaque
+ * string, and subscribe to receive every published string. Ordering and
+ * at-least-once vs at-most-once semantics follow the underlying transport;
+ * ayepi treats delivery as best-effort.
+ *
+ * @example A Redis implementation is ~10 lines:
+ * ```ts
+ * const redisBroker = (pub: Redis, sub: Redis): Broker => ({
+ *   publish: (m) => void pub.publish('ayepi', m),
+ *   subscribe: (l) => {
+ *     void sub.subscribe('ayepi')
+ *     sub.on('message', (_ch, m) => l(m))
+ *     return () => void sub.unsubscribe('ayepi')
+ *   },
+ * })
+ * ```
+ *
+ * @example A Postgres `LISTEN/NOTIFY` implementation:
+ * ```ts
+ * const pgBroker = (client: Client): Broker => ({
+ *   publish: (m) => void client.query('SELECT pg_notify($1, $2)', ['ayepi', m]),
+ *   subscribe: (l) => {
+ *     void client.query('LISTEN ayepi')
+ *     const h = (msg: { payload?: string }) => l(msg.payload ?? '')
+ *     client.on('notification', h)
+ *     return () => client.removeListener('notification', h)
+ *   },
+ * })
+ * ```
+ */
+interface Broker {
+  /** Publish an opaque message to every subscriber across all instances. */
+  publish(message: string): void | Promise<void>;
+  /**
+   * Register a listener for published messages.
+   * @returns an unsubscribe function that detaches the listener.
+   */
+  subscribe(listener: (message: string) => void): () => void;
+}
+/**
+ * In-process {@link Broker} — the default when no broker is supplied.
+ *
+ * Share a single instance between multiple {@link Server}s to simulate a
+ * multi-pod deployment in tests: an `emit` on one server is heard by
+ * subscribers on the other.
+ *
+ * @example
+ * ```ts
+ * const broker = localBroker()
+ * const a = server(api, handlers, { broker })
+ * const b = server(api, handlers, { broker })
+ * a.emit('systemNotice', { msg: 'hi' }) // delivered to b's subscribers too
+ * ```
+ */
+declare function localBroker(): Broker;
+//#endregion
+//#region src/payload.d.ts
+/** Input vs output side of a schema (request parsing vs response/handler view). */
+type IOMode = 'in' | 'out';
+/** Pick `z.input` or `z.output` of a schema by {@link IOMode}. */
+type ZIO<Z extends z.ZodType, M extends IOMode> = M extends 'in' ? z.input<Z> : z.output<Z>;
+type CfgOf<E extends AnyEndpoint> = E['cfg'];
+type CtxOf<E extends AnyEndpoint> = E['__ctx'];
+type LPOf<E extends AnyEndpoint> = E['__lp'];
+type LPShape<E extends AnyEndpoint, M extends IOMode> = { [K in keyof LPOf<E>]: LPOf<E>[K] extends z.ZodType ? ZIO<LPOf<E>[K], M> : never };
+/** Params contributed by a `path` template on `cfg.path`. */
+type TplOf<E extends AnyEndpoint> = Get<CfgOf<E>, 'path'> extends {
+  readonly __ps: infer PS extends object;
+} ? PS : EmptyObject;
+/** Params contributed by stacked path prefixes. */
+type PfxOf<E extends AnyEndpoint> = E extends {
+  readonly __pfx: infer PFX extends object;
+} ? PFX : EmptyObject;
+type PfxShape<E extends AnyEndpoint, M extends IOMode> = { -readonly [K in keyof PfxOf<E>]: PfxOf<E>[K] extends z.ZodType ? ZIO<PfxOf<E>[K], M> : never };
+type TplShape<E extends AnyEndpoint, M extends IOMode> = { -readonly [K in keyof TplOf<E>]: TplOf<E>[K] extends z.ZodType ? ZIO<TplOf<E>[K], M> : never };
+type PShape<E extends AnyEndpoint, M extends IOMode> = Simplify<(Get<CfgOf<E>, 'params'> extends z.ZodType ? ZIO<Get<CfgOf<E>, 'params'> & z.ZodType, M> : EmptyObject) & LPShape<E, M> & TplShape<E, M> & PfxShape<E, M>>;
+type QShape<E extends AnyEndpoint, M extends IOMode> = Get<CfgOf<E>, 'query'> extends z.ZodType ? ZIO<Get<CfgOf<E>, 'query'> & z.ZodType, M> : EmptyObject;
+/** File fields map to data keys; a file schema whose input accepts `undefined` (e.g. `z.file().optional()`) becomes an optional key. */
+type FShape<E extends AnyEndpoint, M extends IOMode> = Get<CfgOf<E>, 'files'> extends infer F extends Readonly<Record<string, z.ZodType>> ? Simplify<{ -readonly [K in keyof F as undefined extends z.input<F[K]> ? never : K]: ZIO<F[K], M> } & { -readonly [K in keyof F as undefined extends z.input<F[K]> ? K : never]?: ZIO<F[K], M> }> : EmptyObject;
+type HShape<E extends AnyEndpoint, M extends IOMode> = Get<CfgOf<E>, 'headers'> extends z.ZodType ? ZIO<Get<CfgOf<E>, 'headers'> & z.ZodType, M> : EmptyObject;
+type CShape<E extends AnyEndpoint, M extends IOMode> = Get<CfgOf<E>, 'cookies'> extends z.ZodType ? ZIO<Get<CfgOf<E>, 'cookies'> & z.ZodType, M> : EmptyObject;
+type HasHeaders<E extends AnyEndpoint> = Get<CfgOf<E>, 'headers'> extends z.ZodType ? true : false;
+type HasCookies<E extends AnyEndpoint> = Get<CfgOf<E>, 'cookies'> extends z.ZodType ? true : false;
+type RespMap<E extends AnyEndpoint> = Get<CfgOf<E>, 'responses'> extends Readonly<Record<number, z.ZodType>> ? Get<CfgOf<E>, 'responses'> : EmptyObject;
+type HasMulti<E extends AnyEndpoint> = [keyof RespMap<E>] extends [never] ? false : true;
+type ErrorsOf<E extends AnyEndpoint> = Get<CfgOf<E>, 'errors'> extends Readonly<Record<number, z.ZodType>> ? Get<CfgOf<E>, 'errors'> : EmptyObject;
+type HasErrors<E extends AnyEndpoint> = [keyof ErrorsOf<E>] extends [never] ? false : true;
+/**
+ * The handler's `fail()` — throw a declared, schema-validated error response.
+ * Only declared statuses are accepted, and the data must match that status's
+ * schema.
+ *
+ * @typeParam Errors - the endpoint's `errors` record.
+ */
+type FailFn<Errors extends object> = <S extends keyof Errors & number>(status: S, data: Errors[S] extends z.ZodType ? z.input<Errors[S]> : never) => never;
+type HasBody<E extends AnyEndpoint> = Get<CfgOf<E>, 'body'> extends z.ZodType ? true : false;
+type HasFiles<E extends AnyEndpoint> = Get<CfgOf<E>, 'files'> extends Readonly<Record<string, z.ZodType>> ? true : false;
+type HasRawStreamIn<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamIn'> extends string ? true : false;
+type HasItemStreamIn<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamIn'> extends z.ZodType ? true : false;
+type InItemSchema<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamIn'> extends z.ZodType ? Get<CfgOf<E>, 'streamIn'> & z.ZodType : never;
+type HasStreamIn<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamIn'> extends string | z.ZodType ? true : false;
+type HasRawStreamOut<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamOut'> extends string ? true : false;
+type HasItemStream<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamOut'> extends z.ZodType ? true : false;
+type ItemSchema<E extends AnyEndpoint> = Get<CfgOf<E>, 'streamOut'> extends z.ZodType ? Get<CfgOf<E>, 'streamOut'> & z.ZodType : never;
+type BRaw<E extends AnyEndpoint, M extends IOMode> = Get<CfgOf<E>, 'body'> extends z.ZodType ? ZIO<Get<CfgOf<E>, 'body'> & z.ZodType, M> : never;
+/** A body merges into the flat object only when it is a plain string-keyed record. */
+type BMergeable<E extends AnyEndpoint, M extends IOMode> = HasBody<E> extends true ? ([BRaw<E, M>] extends [Record<string, unknown>] ? true : false) : false;
+type BFlat<E extends AnyEndpoint, M extends IOMode> = BMergeable<E, M> extends true ? BRaw<E, M> : EmptyObject;
+type NonMergeableBody<E extends AnyEndpoint> = HasBody<E> extends true ? (BMergeable<E, 'in'> extends true ? false : true) : false;
+type ClientFlat<E extends AnyEndpoint> = Simplify<PShape<E, 'in'> & QShape<E, 'in'> & BFlat<E, 'in'> & FShape<E, 'in'>>;
+/**
+ * The single `data` argument the client passes to `call()` — the merged
+ * path/query/body/files object, or the raw value when the body is a non-object
+ * (then it *is* the data).
+ */
+type ClientData<E extends AnyEndpoint> = NonMergeableBody<E> extends true ? BRaw<E, 'in'> : ClientFlat<E>;
+/** Accepted shapes for a raw streaming request body. */
+type StreamBody = ReadableStream<Uint8Array> | Blob | ArrayBuffer | string;
+/**
+ * Whether an endpoint is HTTP-only (cannot use the `'ws'` transport): raw byte
+ * streams and file uploads are HTTP-only; typed item streams travel over ws too.
+ */
+type IsHttpOnly<E extends AnyEndpoint> = Get<CfgOf<E>, 'httpOnly'> extends true ? true : HasFiles<E> extends true ? true : HasRawStreamIn<E> extends true ? true : HasRawStreamOut<E> extends true ? true : false;
+/** Upload progress for a request body, reported to {@link CallOptsBase.onUploadProgress}. */
+interface UploadProgress {
+  /** Bytes uploaded so far. */
+  readonly loaded: number;
+  /** Total bytes to upload. */
+  readonly total: number;
+}
+/** Options common to every `call()`. */
+interface CallOptsBase {
+  /** Abort signal — cancels the in-flight request (and, over ws, the call). */
+  readonly signal?: AbortSignal;
+  /** Extra request headers (also used to deliver typed request headers/cookies). */
+  readonly headers?: Readonly<Record<string, string>>;
+  /**
+   * Report request-upload progress (e.g. a file/multipart or body POST). When set, that request is
+   * sent via `XMLHttpRequest` (the only transport with upload-progress events) instead of `fetch`, so
+   * it bypasses a custom `fetchImpl`. Ignored for streaming endpoints, and a no-op where `XMLHttpRequest`
+   * is unavailable (e.g. server-side) — the call still completes via `fetch`. Browser-oriented.
+   */
+  readonly onUploadProgress?: (progress: UploadProgress) => void;
+}
+/**
+ * The per-call options object. Adds a `transport` choice (narrowed to `'http'`
+ * for HTTP-only endpoints) and a **required** `stream` for streaming-input
+ * endpoints.
+ */
+type CallOpts<E extends AnyEndpoint> = CallOptsBase & (IsHttpOnly<E> extends true ? {
+  readonly transport?: 'http';
+} : {
+  readonly transport?: 'http' | 'ws';
+}) & (HasRawStreamIn<E> extends true ? {
+  readonly stream: StreamBody;
+} : HasItemStreamIn<E> extends true ? {
+  readonly stream: AsyncIterable<z.input<InItemSchema<E>>> | (() => AsyncIterable<z.input<InItemSchema<E>>>);
+} : EmptyObject);
+/** What `call()` resolves to: an async iterable for item streams, a `ReadableStream` for raw streams, a `{ status, data }` union for multi-status, the response, or `void`. */
+type CallReturn<E extends AnyEndpoint> = HasItemStream<E> extends true ? AsyncIterable<z.output<ItemSchema<E>>> : HasRawStreamOut<E> extends true ? Promise<ReadableStream<Uint8Array>> : HasMulti<E> extends true ? Promise<{ [St in keyof RespMap<E> & number]: {
+  status: St;
+  data: z.output<RespMap<E>[St] & z.ZodType>;
+} }[keyof RespMap<E> & number]> : Get<CfgOf<E>, 'response'> extends z.ZodType ? Promise<z.output<Get<CfgOf<E>, 'response'> & z.ZodType>> : Promise<void>;
+/**
+ * The positional arguments to `call(name, …)`, computed per endpoint: data-less
+ * endpoints take `opts?` first; streaming-input endpoints require `opts`; a
+ * non-object body is a required positional value; everything else takes the
+ * merged `data` (optional when every key is optional).
+ */
+type CallArgs<E extends AnyEndpoint> = HasStreamIn<E> extends true ? [keyof ClientData<E>] extends [never] ? [data: undefined, opts: CallOpts<E>] : EmptyObject extends ClientData<E> ? [data: ClientData<E> | undefined, opts: CallOpts<E>] : [data: ClientData<E>, opts: CallOpts<E>] : NonMergeableBody<E> extends true ? [data: ClientData<E>, opts?: CallOpts<E>] : [keyof ClientData<E>] extends [never] ? [opts?: CallOpts<E>] : EmptyObject extends ClientData<E> ? [data?: ClientData<E>, opts?: CallOpts<E>] : [data: ClientData<E>, opts?: CallOpts<E>];
+type HandlerFlat<E extends AnyEndpoint> = Simplify<PShape<E, 'out'> & QShape<E, 'out'> & BFlat<E, 'out'> & FShape<E, 'out'>>;
+type HandlerData<E extends AnyEndpoint> = NonMergeableBody<E> extends true ? BRaw<E, 'out'> : HandlerFlat<E>;
+/** The positional arguments to `emit(name, …)`: `(params, data)` for parameterized events, `(data)` otherwise. */
+type EmitArgs<Ev extends EventConfig> = Get<Ev, 'params'> extends z.ZodType ? [params: z.input<Get<Ev, 'params'> & z.ZodType>, data: z.input<Ev['data']>] : [data: z.input<Ev['data']>];
+/** The typed `emit` function for a spec's events, available on the server and in handlers. */
+type EmitFn<S extends AnySpec> = <K extends keyof EventsOf<S> & string>(name: K, ...args: EmitArgs<EventsOf<S>[K] & EventConfig>) => void;
+/**
+ * The object a handler receives. The middleware context spreads at the root,
+ * alongside a single merged `data`, the declared kinds (`stream`, `headers`,
+ * `cookies`), and the framework toolkit (`req`, `signal`, `emit`, `status()`,
+ * `header()`, `cookie()`, and — gated by config — `out`/`download()`/`length()`/`fail()`).
+ *
+ * @typeParam S - the owning spec (for the typed `emit`).
+ * @typeParam E - the endpoint.
+ */
+type HandlerPayload<S extends AnySpec, E extends AnyEndpoint> = Simplify<CtxOf<E> & (NonMergeableBody<E> extends true ? {
+  readonly data: HandlerData<E>;
+} : [keyof HandlerFlat<E>] extends [never] ? EmptyObject : {
+  readonly data: HandlerData<E>;
+}) & (HasRawStreamIn<E> extends true ? {
+  readonly stream: ReadableStream<Uint8Array>;
+} : EmptyObject) & (HasItemStreamIn<E> extends true ? {
+  readonly stream: AsyncIterable<z.output<InItemSchema<E>>>;
+} : EmptyObject) & (HasRawStreamOut<E> extends true ? {
+  /** Pipe target — `await readable.pipeTo(out)` (or write via `getWriter()`); strings are utf-8 encoded. */
+  readonly out: WritableStream<Uint8Array | string>;
+  /** Set `Content-Disposition`/content-type dynamically; must be called before the first byte streams. */
+  readonly download: (filename: string, contentType?: string) => void;
+  /** Declare the total byte length — enables `Content-Length` and HTTP Range (resumable downloads). */
+  readonly length: (totalBytes: number) => void;
+} : EmptyObject) & (HasHeaders<E> extends true ? {
+  readonly headers: HShape<E, 'out'>;
+} : EmptyObject) & (HasCookies<E> extends true ? {
+  readonly cookies: CShape<E, 'out'>;
+} : EmptyObject) & (HasErrors<E> extends true ? {
+  readonly fail: FailFn<ErrorsOf<E>>;
+} : EmptyObject) & {
+  readonly req: Request;
+  readonly signal: AbortSignal;
+  readonly emit: EmitFn<S>;
+  /** Override the HTTP status (default 200/204/201…); HTTP transport only, before the first streamed byte. */
+  readonly status: (code: number) => void;
+  /** Set a response header; HTTP transport only, before the first streamed byte. */
+  readonly header: (name: string, value: string) => void;
+  /** Append a `Set-Cookie` header; HTTP transport only. */
+  readonly cookie: (name: string, value: string, opts?: CookieOptions) => void;
+}>;
+/** What a handler may return, per endpoint: an item-stream iterable, raw bytes, a `{ status, data }` union, the response, or `void`. */
+type HandlerReturn<E extends AnyEndpoint> = HasItemStream<E> extends true ? MaybePromise<AsyncIterable<z.output<ItemSchema<E>>>> : HasRawStreamOut<E> extends true ? MaybePromise<ReadableStream<Uint8Array> | AsyncIterable<string | Uint8Array> | void> : HasMulti<E> extends true ? MaybePromise<{ [St in keyof RespMap<E> & number]: {
+  readonly status: St;
+  readonly data: z.input<RespMap<E>[St] & z.ZodType>;
+} }[keyof RespMap<E> & number]> : Get<CfgOf<E>, 'response'> extends z.ZodType ? MaybePromise<z.output<Get<CfgOf<E>, 'response'> & z.ZodType>> : MaybePromise<void>;
+/** A handler function for endpoint `E` of spec `S`. */
+type HandlerFor<S extends AnySpec, E extends AnyEndpoint> = (payload: HandlerPayload<S, E>) => HandlerReturn<E>;
+//#endregion
+//#region src/docs-ui.d.ts
+/**
+ * # Docs UI
+ *
+ * Self-contained HTML pages that render the generated OpenAPI / AsyncAPI
+ * documents, pulling their viewer libraries from a CDN (no bundled dependency).
+ * Used by {@link server} when the `docs` option is enabled — it serves the spec
+ * JSON (computed once and cached in memory) plus a Swagger UI, a ReDoc, and an
+ * AsyncAPI page.
+ *
+ * @module
+ */
+/** Configuration for the built-in documentation routes (`ServerOptions.docs`). */
+interface DocsOptions {
+  /** `info` (title/version) passed to the generated documents. */
+  readonly info?: {
+    title?: string;
+    version?: string;
+  };
+  /** Path serving the OpenAPI 3.1 JSON (default `/docs/openapi.json`); `false` to disable. */
+  readonly openapiJson?: string | false;
+  /** Path serving the AsyncAPI 3.0 JSON (default `/docs/asyncapi.json`); `false` to disable. */
+  readonly asyncapiJson?: string | false;
+  /** Path serving the Swagger UI page (default `/docs/swagger`); `false` to disable. */
+  readonly swagger?: string | false;
+  /** Path serving the ReDoc page (default `/docs/redoc`); `false` to disable. */
+  readonly redoc?: string | false;
+  /** Path serving the AsyncAPI viewer page (default `/docs/asyncapi`); `false` to disable. */
+  readonly asyncapi?: string | false;
+}
+/** Fully-resolved docs routes (internal). @internal */
+
+/** A self-contained Swagger UI page (loaded from unpkg) pointed at `specUrl`. */
+declare function swaggerHtml(specUrl: string, title?: string): string;
+/** A self-contained ReDoc page (loaded from the Redocly CDN) pointed at `specUrl`. */
+declare function redocHtml(specUrl: string, title?: string): string;
+/** A self-contained AsyncAPI page (the `@asyncapi/web-component`, loaded from unpkg) pointed at `specUrl`. */
+declare function asyncapiHtml(specUrl: string, title?: string): string;
+//#endregion
+//#region src/server.d.ts
+/** internal: the accumulated handler + middleware-impl bindings behind an {@link Implementor}. */
+interface ImplBag {
+  readonly handlers: Map<string, (payload: never) => unknown>;
+  readonly middleware: Map<AnyMiddleware, AnyFn>;
+}
+/**
+ * Returned by {@link implement} — a chainable builder that accumulates endpoint
+ * handlers and middleware impls for a spec. Bind middleware defs to their runtime
+ * fns with {@link Implementor.middleware | .middleware}, and endpoint handlers with
+ * {@link Implementor.handlers | .handlers}/{@link Implementor.handle | .handle}.
+ * Hand the builder(s) to {@link server}, which requires every endpoint to have
+ * exactly one handler and every chain middleware to be bound.
+ *
+ * @typeParam HK - the union of endpoint names handled so far (drives {@link server}'s
+ *   missing-handler compile check).
+ */
+interface Implementor<S extends AnySpec, HK extends keyof S['endpoints'] & string = never> {
+  /** Bind a middleware **def** to its runtime impl (or a loader def to its loader impl). */
+  middleware<M extends AnyMiddleware>(def: M, impl: ImplFor<M>): Implementor<S, HK>;
+  /** Bind a package-built `{ def, impl }` pair (e.g. `bearerAuth.server(def, cfg)`). */
+  middleware<M extends AnyMiddleware>(bound: BoundMiddleware<M>): Implementor<S, HK>;
+  /** Provide a bag of handlers (a partial map of endpoint name → handler). */
+  handlers<K extends keyof S['endpoints'] & string>(h: { [P in K]: HandlerFor<S, S['endpoints'][P]> }): Implementor<S, HK | K>;
+  /** Provide a single handler by name. */
+  handle<K extends keyof S['endpoints'] & string>(name: K, fn: HandlerFor<S, S['endpoints'][K]>): Implementor<S, HK | K>;
+  /** @internal the accumulated bindings — read by {@link server}. */
+  readonly __bag: ImplBag;
+  /** @internal type-only carrier of the handled-endpoint union — matched by {@link server} without expanding the methods. */
+  readonly __hk?: HK;
+}
+/**
+ * Begin implementing a spec. The returned {@link Implementor} is a chainable
+ * builder: bind middleware impls with `.middleware(def, impl)` and endpoint
+ * handlers with `.handlers({...})`/`.handle(name, fn)`, then hand it to
+ * {@link server}. Split work across multiple `implement()` builders if you like —
+ * `server()` merges them.
+ *
+ * @example
+ * ```ts
+ * const impl = implement(api)
+ *   .middleware(auth, async (io) => io.next({ user: await authenticate(io.req) }))
+ *   .handlers({ getUser: ({ data }) => loadUser(data.id) })
+ * ```
+ */
+declare function implement<S extends AnySpec>(spec: S): Implementor<S>;
+/** A live WebSocket connection, as seen by the server's ws handler. */
+interface WsConn {
+  readonly id: number;
+  readonly req: Request;
+  /** internal */
+  readonly send: (frame: string) => void;
+  /** internal */
+  readonly subs: Set<string>;
+  /** internal */
+  readonly streams: Map<string, {
+    push(v: unknown): void;
+    end(): void;
+    fail(err: unknown): void;
+  }>;
+  /** internal: per-call abort controllers, so an `{ id, abort: true }` frame can cancel a call */
+  readonly calls: Map<string, AbortController>;
+}
+/** Cross-origin resource sharing configuration. */
+interface CorsOptions {
+  /** Allowed origin(s): `'*'`, a single origin, or an allow-list. */
+  readonly origin: '*' | string | readonly string[];
+  /** Whether to send `Access-Control-Allow-Credentials`. */
+  readonly credentials?: boolean;
+  /** Preflight cache duration (seconds). */
+  readonly maxAge?: number;
+  /** Response headers to expose to the browser. */
+  readonly exposeHeaders?: readonly string[];
+}
+/** Options for {@link server}. */
+interface ServerOptions {
+  readonly cors?: CorsOptions;
+  /** Event fanout across server instances (default: in-process {@link localBroker}). */
+  readonly broker?: Broker;
+  /**
+   * Serve interactive API documentation. `true` mounts the defaults
+   * (`/openapi.json`, `/asyncapi.json`, `/docs` Swagger UI, `/redoc`, `/asyncapi`);
+   * pass a {@link DocsOptions} object to customize paths or disable pages. The
+   * spec JSON is generated once and cached in memory.
+   */
+  readonly docs?: boolean | DocsOptions;
+}
+/** The assembled server: a fetch handler, a ws handler, the manifest, `emit`, and doc generators. */
+interface Server<S extends AnySpec> {
+  readonly spec: S;
+  /** The entire HTTP surface — pass any `Request`, get a `Response`. */
+  fetch(req: Request): Promise<Response>;
+  /** The zod-free runtime manifest the client routes from (also derivable via {@link manifestFromSpec}). */
+  manifest(): Manifest;
+  /** Publish a typed event to all subscribers (across instances via the {@link Broker}). */
+  emit: EmitFn<S>;
+  /** Generate the OpenAPI 3.1 document. */
+  openapi(info?: {
+    title?: string;
+    version?: string;
+  }): Json;
+  /** Generate the AsyncAPI 3.0 document. */
+  asyncapi(info?: {
+    title?: string;
+    version?: string;
+  }): Json;
+  /**
+   * Call one of this server's endpoints **in-process** by name with just its data
+   * payload — runs the full middleware chain + validation, but skips HTTP
+   * serialization. The invocation's `io.transport` is `'local'`. Pass `headers` via
+   * `opts` to satisfy auth-style middleware. Streaming/file endpoints are best
+   * called over a {@link client} instead.
+   *
+   * The result is loosely typed here (a low-level escape hatch) — for the typed
+   * surface use {@link localClient}, which returns a {@link LocalClient}.
+   */
+  call<K extends keyof S['endpoints'] & string>(name: K, ...args: LocalCallArgs<S['endpoints'][K]>): Promise<unknown>;
+  /**
+   * Mount another spec + its builders into this **running** server — its endpoints,
+   * events, routes, and middleware go live immediately and the manifest/docs caches
+   * refresh. Typed like {@link server}: every endpoint needs a handler and every
+   * chain middleware a binding (a shared middleware def already bound by an earlier
+   * mount is reused, not re-bound). Collisions (endpoint name / route / ws / event)
+   * throw. Returns a {@link MountHandle} for {@link Server.uninstall}.
+   */
+  install<S2 extends AnySpec, const H2 extends readonly {
+    readonly __hk?: keyof S2['endpoints'] & string;
+  }[]>(spec: S2, builders: H2, ...rest: [MissingHandlers<S2, H2>] extends [never] ? [] : [error: {
+    readonly missingHandlers: MissingHandlers<S2, H2>;
+  }]): MountHandle;
+  /** Remove a previously {@link Server.install | installed} mount — deletes exactly its endpoints, events, routes, and bindings, and clears its subscriptions. */
+  uninstall(handle: MountHandle): void;
+  /** WebSocket lifecycle hooks for an adapter to drive. */
+  readonly ws: {
+    /** Register a new connection given its `send` and the upgrade `Request`. */
+    open(send: (frame: string) => void, req: Request): WsConn;
+    /** Handle one inbound text frame. */
+    message(conn: WsConn, raw: string): Promise<void>;
+    /** Tear down a connection (cleans up its subscriptions). */
+    close(conn: WsConn): void;
+  };
+}
+/** Per-call options for an in-process {@link Server.call} / {@link LocalClient}. */
+interface LocalCallOptions {
+  /** Request headers visible to the chain (e.g. an `authorization` token for auth middleware). */
+  readonly headers?: Readonly<Record<string, string>>;
+  /** Abort signal for the call. */
+  readonly signal?: AbortSignal;
+}
+/** The arguments an in-process call takes: `[opts?]` when the endpoint has no input, else `[data, opts?]`. */
+type LocalCallArgs<E extends AnyEndpoint> = [keyof ClientData<E>] extends [never] ? [opts?: LocalCallOptions] : [data: ClientData<E>, opts?: LocalCallOptions];
+/**
+ * A typed in-process caller for a spec's endpoints — the no-serialization loopback
+ * over {@link Server.call}, retyped against `S`. Use it to invoke another spec's
+ * endpoints (e.g. a dependency's) from server-side code with just a data payload.
+ */
+interface LocalClient<S extends AnySpec> {
+  call<K extends keyof S['endpoints'] & string>(name: K, ...args: LocalCallArgs<S['endpoints'][K]>): CallReturn<S['endpoints'][K]>;
+}
+/**
+ * View a running {@link Server} as a typed {@link LocalClient} for spec `S` — for
+ * calling endpoints in-process (full chain + validation, no HTTP) by name + data.
+ *
+ * @param app  - the running server (its `call` is the in-process caller).
+ * @param spec - the spec to type against (its endpoints/`CallReturn` shape `S`).
+ *
+ * @example
+ * ```ts
+ * const users = localClient(app, usersSpec);
+ * const u = await users.call('getUser', { id: 'u1' });   // typed, in-process
+ * ```
+ */
+declare function localClient<S extends AnySpec>(app: Server<AnySpec>, spec?: S): LocalClient<S>;
+/** The endpoint-name union a builder has handled — read off its `__hk` phantom (never expands the methods). */
+type BuilderKeys<B> = B extends {
+  readonly __hk?: infer K;
+} ? K : never;
+/** Endpoint names with no handler across the supplied builders — surfaced as a compile error. */
+type MissingHandlers<S extends AnySpec, H extends readonly unknown[]> = Exclude<keyof S['endpoints'] & string, BuilderKeys<H[number]>>;
+/** Loosest internal function type — replaces the banned `Function` in plumbing signatures. */
+type AnyFn = (...args: never[]) => unknown;
+/** internal: a normalized event with its guard chain bound — held in the live `events` registry. */
+interface LiveEvent {
+  readonly name: string;
+  readonly cfg: EventConfig;
+  readonly ws: string;
+  readonly chain: AnyMiddleware[];
+}
+/**
+ * An opaque handle to a mounted spec, returned by {@link Server.install} and passed
+ * back to {@link Server.uninstall} to remove exactly what that install added.
+ */
+interface MountHandle {
+  /** @internal the normalized endpoints this mount added. */
+  readonly eps: readonly NormalizedEp[];
+  /** @internal the live events this mount added. */
+  readonly events: readonly LiveEvent[];
+  /** @internal the middleware defs this mount bound (removed from the global impl map on uninstall). */
+  readonly impls: readonly AnyMiddleware[];
+  /** @internal this mount's spec-level doc patch, if any. */
+  readonly doc: SpecDoc | undefined;
+}
+/**
+ * Assemble a {@link Server} from a spec and one or more {@link implement} builders.
+ *
+ * Every endpoint must have exactly one handler: a missing handler is a **compile
+ * error** that names the offending endpoints (via the final `error` argument), and
+ * a duplicate/unknown handler throws at startup. Every middleware in an endpoint or
+ * event-guard chain must be bound via `.middleware(def, impl)` — an unbound def
+ * throws at assembly.
+ *
+ * @param spec     - the validated spec from {@link spec}.
+ * @param builders - one or more builders from {@link implement}.
+ * @param rest     - `[options?]` when all handlers are present, else `[{ missingHandlers }]`.
+ *
+ * @example
+ * ```ts
+ * const app = server(api, [implement(api).middleware(auth, authImpl).handlers({ … })], { cors, broker })
+ * const res = await app.fetch(new Request('http://x/getUser/u1', { method: 'POST' }))
+ * ```
+ */
+declare function server<S extends AnySpec, const H extends readonly {
+  readonly __hk?: keyof S['endpoints'] & string;
+}[]>(spec: S, builders: H, ...rest: [MissingHandlers<S, H>] extends [never] ? [options?: ServerOptions] : [error: {
+  readonly missingHandlers: MissingHandlers<S, H>;
+}]): Server<S>;
+//#endregion
+//#region src/middleware.d.ts
+/** Which transport an invocation arrived on (`'local'` = an in-process {@link LocalClient} call). */
+type Transport = 'http' | 'ws' | 'local';
+/**
+ * The matched route a middleware is running for. A discriminated union: an
+ * **endpoint** (with `method`/`path`/`ws` id) or an **event** channel (guard
+ * chains run when a client subscribes), which has no method/path.
+ */
+type RouteInfo = {
+  readonly kind: 'endpoint';
+  readonly name: string;
+  readonly method: HttpMethod;
+  readonly path: string;
+  readonly ws: string | null;
+} | {
+  readonly kind: 'event';
+  readonly name: string;
+  readonly ws: string;
+};
+/** WebSocket frame context, present on {@link MiddlewareIO.ws} only when `transport === 'ws'`. */
+interface WsFrameInfo {
+  /** The frame id (the per-call correlation id) — the ws equivalent of a request id. */
+  readonly id: string;
+  /** The raw frame payload (`data` for calls, `params` for event subscriptions). Narrow it yourself. */
+  readonly data: unknown;
+  /** The WebSocket connection this frame arrived on. */
+  readonly conn: WsConn;
+}
+declare const MW_PROVIDES: unique symbol;
+/**
+ * Opaque token returned by `next()`; carries (type-only) the context a
+ * middleware provides so the next link and the handler can see it.
+ *
+ * @typeParam P - the context shape this step contributes.
+ */
+interface MiddlewareResult<P extends object> {
+  readonly [MW_PROVIDES]?: P;
+}
+/**
+ * The argument passed to a middleware function.
+ *
+ * @typeParam Req - the accumulated context from earlier middleware in the chain.
+ */
+interface MiddlewareIO<Req extends object> {
+  /** The incoming request. Over ws this is the connection's HTTP **upgrade** request (shared per socket), not the frame. */
+  readonly req: Request;
+  /** Context accumulated so far (read-only snapshot). */
+  readonly ctx: Simplify<Req>;
+  /**
+   * The raw, **pre-validation** request body — the parsed JSON / urlencoded-form object
+   * (or, for a multipart request, its non-file fields), the ws call's data, or `undefined`
+   * when the request declares no body. Read it to derive idempotency/cache keys, sign or
+   * log the payload, etc. The typed, validated body still reaches the handler as `data`.
+   */
+  readonly body: unknown;
+  /**
+   * Continue the chain, optionally contributing context. The added shape is
+   * inferred and becomes visible to later middleware and the handler. Every
+   * middleware **must** call `next()` (or throw) exactly once.
+   */
+  readonly next: <T extends object = EmptyObject>(add?: T) => Promise<MiddlewareResult<T>>;
+  /** Which transport this invocation arrived on (`'http'` or `'ws'`). */
+  readonly transport: Transport;
+  /** The matched route — an endpoint (with `method`/`path`/`ws`) or an event channel. Use `route.method`/`route.path` for transport-neutral identity. */
+  readonly route: RouteInfo;
+  /** The abort signal for this invocation (the HTTP request signal, or the ws call's per-frame signal). */
+  readonly signal: AbortSignal;
+  /** WebSocket frame context — present only when `transport === 'ws'` (carries the frame `id`, raw `data`, and `conn`). */
+  readonly ws?: WsFrameInfo;
+  /** Set a response header. Applies over HTTP (collected with the handler's headers); collected-but-unused over ws. Must run before the response commits. */
+  readonly setHeader: (name: string, value: string) => void;
+  /** Set the response status — the HTTP status code, or a ws call's result-frame `$status`. Must run before the response commits. */
+  readonly status: (code: number) => void;
+}
+/**
+ * A plain middleware function. Either continue the chain via `io.next(…)` (the
+ * common case) or **short-circuit** by returning a `Response` directly — the rest
+ * of the chain and the handler are skipped. Over HTTP the `Response` is sent
+ * as-is; over ws a JSON body becomes a result frame and anything else an error
+ * frame.
+ */
+type MiddlewareFn<Req extends object, P extends object> = (io: MiddlewareIO<Req>) => Promise<MiddlewareResult<P> | Response>;
+/** A loader middleware function — additionally receives the parsed, typed param `value`. May also short-circuit with a `Response`. */
+type LoaderFn<Req extends object, Z extends z.ZodType, P extends object> = (io: MiddlewareIO<Req> & {
+  readonly value: z.output<Z>;
+}) => Promise<MiddlewareResult<P> | Response>;
+/**
+ * Erased middleware shape used by the runtime and by variance-friendly
+ * constraints. Carries phantom fields (`__p`/`__req`/`__lp`/`__opt`/`__isLoader`/
+ * `__lz`) that are type-only.
+ *
+ * A middleware value is a **def** (contract only): its {@link AnyMiddleware.run}
+ * is an unbound placeholder that throws if executed. The runtime fn is supplied
+ * separately via `implement(api).middleware(def, impl)` and bound at `server()`.
+ *
+ * @internal
+ */
+interface AnyMiddleware {
+  readonly kind: 'middleware';
+  readonly name: string;
+  readonly requires: readonly AnyMiddleware[];
+  readonly optional: readonly AnyMiddleware[];
+  readonly paramKey: string | undefined;
+  readonly paramSchema: z.ZodType | undefined;
+  readonly doc: MiddlewareDoc | undefined;
+  /** internal: loosest possible run signature; on a def it is an unbound placeholder that throws. */
+  readonly run: (io: {
+    req: Request;
+    ctx: never;
+    next: (add?: object) => Promise<MiddlewareResult<object>>;
+    value?: never;
+  }) => Promise<MiddlewareResult<object> | Response>;
+  readonly __p: object;
+  readonly __req: readonly AnyMiddleware[];
+  readonly __lp: object;
+  /** internal phantom: the `optional` list, so an impl's `io.ctx` can include `Partial<provides-of-optional>`. */
+  readonly __opt: readonly AnyMiddleware[];
+  /** internal phantom: `true` only for `middleware.loader` defs — selects the loader-shaped impl. */
+  readonly __isLoader: boolean;
+  /** internal phantom: a loader def's own param schema (the `value` an impl receives); `ZodNever` for non-loaders. */
+  readonly __lz: z.ZodType;
+}
+/** Everything a middleware provides, including (recursively) what its `requires` provide. */
+type FullProvides<M extends AnyMiddleware> = M['__p'] & ListProvides<M['__req']>;
+type DistFullProvides<M extends AnyMiddleware> = M extends AnyMiddleware ? FullProvides<M> : never;
+type ListProvides<Ms extends readonly AnyMiddleware[]> = [Ms[number]] extends [never] ? EmptyObject : UnionToIntersection<DistFullProvides<Ms[number]>>;
+/** Loader params contributed by a middleware, including its `requires` chain. */
+type FullLP<M extends AnyMiddleware> = M['__lp'] & ListLP<M['__req']>;
+type DistFullLP<M extends AnyMiddleware> = M extends AnyMiddleware ? FullLP<M> : never;
+type ListLP<Ms extends readonly AnyMiddleware[]> = [Ms[number]] extends [never] ? EmptyObject : UnionToIntersection<DistFullLP<Ms[number]>>;
+/** The merged context a stack of middleware contributes to the handler payload. */
+type StackCtx<Ms extends readonly AnyMiddleware[]> = Simplify<ListProvides<Ms>>;
+/** The merged loader-param schemas a stack of middleware declares. */
+type StackLP<Ms extends readonly AnyMiddleware[]> = Simplify<ListLP<Ms>>;
+/** Param schemas declared by a path template (position + schema); plain strings contribute positions only. */
+type TplPS<T> = T extends {
+  readonly __ps: infer PS extends object;
+} ? PS : EmptyObject;
+/** Stacked prefixes must not re-declare param keys already owned by a loader or earlier prefix. */
+type CheckPrefix<T, LP extends object, PFX extends object> = T extends {
+  readonly __ps: infer PS;
+} ? [keyof PS & (keyof LP | keyof PFX)] extends [never] ? unknown : readonly ['prefix re-declares param keys:', keyof PS & (keyof LP | keyof PFX)] : unknown;
+/**
+ * A single middleware value, with fluent builders for composing it with others
+ * ({@link Middleware.with | .with}), prepending a path prefix
+ * ({@link Middleware.path | .path}), or attaching endpoints
+ * ({@link Middleware.endpoint | .endpoint} / {@link Middleware.group | .group}).
+ *
+ * @typeParam P  - context this middleware provides.
+ * @typeParam R  - its `requires` chain.
+ * @typeParam LP - loader-param schemas it (and its requires) declare.
+ */
+interface Middleware<P extends object, R extends readonly AnyMiddleware[], LP extends object> extends AnyMiddleware {
+  readonly __p: P;
+  readonly __req: R;
+  readonly __lp: LP;
+  /** Compose this middleware with more, producing a {@link Stack}. */
+  with<M extends readonly AnyMiddleware[]>(...mws: M): Stack<readonly [Middleware<P, R, LP>, ...M], EmptyObject>;
+  /** Prepend a path prefix; template params merge into every endpoint defined under it. */
+  path<const T extends string | AnyPathTemplate>(p: T & CheckPrefix<T, LP, EmptyObject>): Stack<readonly [Middleware<P, R, LP>], Simplify<TplPS<T>>>;
+  /** Define a single endpoint guarded by this middleware. */
+  endpoint<const C extends EndpointConfig>(cfg: C & CheckCfg<C, StackLP<readonly [Middleware<P, R, LP>]>, EmptyObject>): Endpoint<C, StackCtx<readonly [Middleware<P, R, LP>]>, StackLP<readonly [Middleware<P, R, LP>]>, EmptyObject>;
+  /** Define a named group of endpoints, all guarded by this middleware. */
+  group<const G extends Record<string, EndpointConfig>>(g: G & { [K in keyof G]: CheckCfg<G[K], StackLP<readonly [Middleware<P, R, LP>]>, EmptyObject> }): { [K in keyof G]: Endpoint<G[K], StackCtx<readonly [Middleware<P, R, LP>]>, StackLP<readonly [Middleware<P, R, LP>]>, EmptyObject> };
+}
+/**
+ * A bundle of middleware plus optional path prefixes, ready to attach endpoints.
+ *
+ * @typeParam Ms  - the middleware list, in declared order.
+ * @typeParam PFX - param schemas contributed by stacked path prefixes.
+ */
+interface Stack<Ms extends readonly AnyMiddleware[], PFX extends object> {
+  readonly kind: 'stack';
+  readonly mws: Ms;
+  readonly prefixes: ReadonlyArray<string | AnyPathTemplate>;
+  /** Append more middleware to the stack. */
+  with<M extends readonly AnyMiddleware[]>(...mws: M): Stack<readonly [...Ms, ...M], PFX>;
+  /** Prepend a path prefix; template params merge into every endpoint defined under it. */
+  path<const T extends string | AnyPathTemplate>(p: T & CheckPrefix<T, StackLP<Ms>, PFX>): Stack<Ms, Simplify<PFX & TplPS<T>>>;
+  /** Define a single endpoint under this stack. */
+  endpoint<const C extends EndpointConfig>(cfg: C & CheckCfg<C, StackLP<Ms>, PFX>): Endpoint<C, StackCtx<Ms>, StackLP<Ms>, PFX>;
+  /** Define a named group of endpoints under this stack. */
+  group<const G extends Record<string, EndpointConfig>>(g: G & { [K in keyof G]: CheckCfg<G[K], StackLP<Ms>, PFX> }): { [K in keyof G]: Endpoint<G[K], StackCtx<Ms>, StackLP<Ms>, PFX> };
+}
+declare const PROVIDE: unique symbol;
+/**
+ * Phantom carrier for the context type a middleware **provides**. Pass
+ * `provides: ctx<{ user: User }>()` to a {@link middleware} def to declare what it
+ * contributes to the handler payload — the type the impl must produce and that
+ * later middleware and handlers can read. Frontend-safe: a type-only token.
+ *
+ * @typeParam P - the context shape contributed.
+ */
+interface Provide<P extends object> {
+  readonly [PROVIDE]?: P;
+}
+/**
+ * Declare the context a middleware def provides — `provides: ctx<{ user: User }>()`.
+ * Returns a type-only token; carries no runtime value.
+ */
+declare function ctx<P extends object>(): Provide<P>;
+/** Options accepted by the {@link middleware} factory. */
+interface MiddlewareOpts<P extends object, R extends readonly AnyMiddleware[], O extends readonly AnyMiddleware[]> {
+  /** The context this middleware contributes — `provides: ctx<{ user: User }>()`. Omit for a no-context (purely-runtime) def. */
+  readonly provides?: Provide<P>;
+  /** Middleware that are auto-included and guaranteed to run before this one. */
+  readonly requires?: R;
+  /** Middleware that, *if independently present*, run before this one — without being pulled in. */
+  readonly optional?: O;
+  /** OpenAPI contributions (security schemes + per-operation patches). */
+  readonly doc?: MiddlewareDoc;
+}
+/** A middleware **def**: the `Middleware` contract plus type-only phantoms an impl binds against. */
+type Def<M extends AnyMiddleware, O extends readonly AnyMiddleware[], IsLoader extends boolean, Z extends z.ZodType> = M & {
+  readonly __opt: O;
+  readonly __isLoader: IsLoader;
+  readonly __lz: Z;
+};
+/**
+ * The type a plain (non-loader) {@link middleware} **def** has — the `Middleware` contract plus the
+ * phantoms its `.server` binding reads. Give a def factory this as an **explicit** return type so its
+ * inferred type stays portable across packages (avoids TS2742 from deep `@ayepi/core` type paths):
+ *
+ * ```ts
+ * export function myMw<const R extends readonly AnyMiddleware[] = readonly []>(): MiddlewareDef<MyCtx, R> {
+ *   return middleware('myMw', { provides: ctx<MyCtx>(), requires: [] as R });
+ * }
+ * ```
+ */
+type MiddlewareDef<P extends object, R extends readonly AnyMiddleware[] = readonly []> = Def<Middleware<P, R, Simplify<ListLP<R>>>, readonly [], false, z.ZodNever>;
+/**
+ * The {@link middleware} factory: callable to create a plain middleware **def**,
+ * with a {@link MiddlewareFactory.loader | .loader} method for param-loading defs.
+ *
+ * A def is a contract only — no runtime fn, no secrets, no node deps — so it is
+ * safe to declare in a frontend-importable spec. Bind the implementation later
+ * with `implement(api).middleware(def, impl)`.
+ */
+interface MiddlewareFactory {
+  /**
+   * Create a middleware def. Declare its contributed context via `provides`, its
+   * dependencies via `requires`/`optional`, and OpenAPI patches via `doc`.
+   */
+  <P extends object = EmptyObject, const R extends readonly AnyMiddleware[] = readonly [], const O extends readonly AnyMiddleware[] = readonly []>(name: string, opts?: MiddlewareOpts<P, R, O>): Def<Middleware<P, R, Simplify<ListLP<R>>>, O, false, z.ZodNever>;
+  /**
+   * Create a **loader** def that owns a path param: it declares `key` + `schema`
+   * and parses the matching segment. Its impl receives the typed `value`, and the
+   * parsed param flows to the handler's `data`.
+   */
+  loader: <P extends object = EmptyObject, K extends string = string, Z extends z.ZodType = z.ZodType, const R extends readonly AnyMiddleware[] = readonly [], const O extends readonly AnyMiddleware[] = readonly []>(key: K, schema: Z, opts?: MiddlewareOpts<P, R, O>) => Def<Middleware<P, R, Simplify<ListLP<R> & { [Q in K]: Z }>>, O, true, Z>;
+}
+/**
+ * Compose one or more middleware into a {@link Stack} — the free-function form of
+ * {@link Middleware.with | mw.with(...)}, which reads more naturally when bundling
+ * several middleware at a group: `...use(auth, tel).group({ … })` instead of
+ * `...auth.with(tel).group({ … })`.
+ *
+ * The middleware run in the order given (subject to `requires`/`optional`
+ * resolution), exactly as with `.with()`.
+ *
+ * @typeParam M - the middleware list, in declared order (at least one).
+ *
+ * @example
+ * ```ts
+ * spec({
+ *   endpoints: {
+ *     ...use(auth, tel).group({ me, createJob }),
+ *     ...use(auth, jobLoader).path('/jobs/:jobId').group({ jobStatus }),
+ *   },
+ * })
+ * ```
+ */
+declare function use<const M extends readonly [AnyMiddleware, ...AnyMiddleware[]]>(...mws: M): Stack<M, EmptyObject>;
+/**
+ * Create a middleware **def** — a frontend-safe contract (name, contributed
+ * context, docs, dependencies) with **no** runtime fn. Bind the implementation
+ * with `implement(api).middleware(def, impl)` in your server entry.
+ *
+ * @example A plain def that provides `{ user }`:
+ * ```ts
+ * const auth = middleware('auth', { provides: ctx<{ user: User }>() })
+ * // server.ts:
+ * implement(api).middleware(auth, async (io) => io.next({ user: await authenticate(io.req) }))
+ * ```
+ *
+ * @example A def that requires `auth` (auto-included) and provides `{ org }`:
+ * ```ts
+ * const org = middleware('org', { provides: ctx<{ org: Org }>(), requires: [auth] })
+ * // server.ts:
+ * implement(api).middleware(org, async (io) => io.next({ org: await loadOrg(io.ctx.user) }))
+ * ```
+ *
+ * @example A no-context, purely-runtime def (e.g. logging/telemetry):
+ * ```ts
+ * const log = middleware('log')
+ * implement(api).middleware(log, async (io) => io.next())
+ * ```
+ *
+ * @example A loader def that owns the `:projectId` path param:
+ * ```ts
+ * const project = middleware.loader('projectId', z.uuid(), { provides: ctx<{ project: Project }>() })
+ * // server.ts:
+ * implement(api).middleware(project, async (io) => io.next({ project: await loadProject(io.value) }))
+ * ```
+ */
+declare const middleware: MiddlewareFactory;
+/**
+ * The impl signature a plain middleware def expects — a {@link MiddlewareFn} whose
+ * `io.ctx` is the def's `requires` context plus `Partial<optional>` context, and
+ * which must produce the def's provided context `M['__p']`.
+ *
+ * @typeParam M - the middleware def.
+ */
+type MiddlewareImplFor<M extends AnyMiddleware> = MiddlewareFn<Simplify<ListProvides<M['__req']> & Partial<ListProvides<M['__opt']>>>, M['__p']>;
+/**
+ * The impl signature a loader def expects — a {@link LoaderFn} that additionally
+ * receives the typed `value` parsed from the def's own param schema (`M['__lz']`).
+ *
+ * @typeParam M - the loader middleware def.
+ */
+type LoaderImplFor<M extends AnyMiddleware> = LoaderFn<Simplify<ListProvides<M['__req']> & Partial<ListProvides<M['__opt']>>>, M['__lz'], M['__p']>;
+/**
+ * The impl signature for a def — {@link LoaderImplFor} for loader defs (those whose
+ * `__isLoader` is `true`), otherwise {@link MiddlewareImplFor}.
+ *
+ * @typeParam M - the middleware def.
+ */
+type ImplFor<M extends AnyMiddleware> = M['__isLoader'] extends true ? LoaderImplFor<M> : MiddlewareImplFor<M>;
+/**
+ * A def paired with its impl — what a package's `*.server(def, config)` binder
+ * returns, ready to hand to `implement(api).middleware(bound)`.
+ *
+ * @typeParam M - the middleware def.
+ */
+interface BoundMiddleware<M extends AnyMiddleware> {
+  readonly def: M;
+  readonly impl: ImplFor<M>;
+}
+/** The single-key context a {@link provide} middleware contributes: `{ [name]: value }`. */
+type Provided<N extends string, V> = { readonly [K in N]: V };
+/**
+ * The value {@link provide} returns: a middleware **def** that is also its own
+ * {@link BoundMiddleware}. Use it directly in a spec chain (`use(svc).group(…)`,
+ * `svc.endpoint(…)`) **and** bind it once with `implement(api).middleware(svc)`.
+ *
+ * The phantoms are pinned concretely (`__opt: []`, `__isLoader: false`) and `impl`
+ * is written out (not via `ImplFor`) so the type stays finite.
+ *
+ * @typeParam N - the context key the value is injected under.
+ * @typeParam V - the injected value's type (`io.ctx[name]`).
+ */
+interface ProvideMiddleware<N extends string, V> extends Middleware<Provided<N, V>, readonly [], EmptyObject> {
+  readonly __opt: readonly [];
+  readonly __isLoader: false;
+  readonly __lz: z.ZodNever;
+  readonly def: ProvideMiddleware<N, V>;
+  readonly impl: MiddlewareFn<EmptyObject, Provided<N, V>>;
+}
+/**
+ * Create a middleware that **injects a typed value** onto the handler context under
+ * `name` — the one-call form of `middleware(name, { provides: ctx<{ [name]: V }>() })`
+ * plus its impl. Hand it a function, a service object, config, or any data, and every
+ * endpoint whose chain includes it reads `io.ctx[name]`.
+ *
+ * The result is **both** the def (use it in the spec: `use(svc).group(…)` /
+ * `svc.endpoint(…)`) and the bound def+impl (bind it once:
+ * `implement(api).middleware(svc)`).
+ *
+ * @typeParam N - the context key (a string literal).
+ * @typeParam V - the injected value's type.
+ * @param name  - the key the value is injected under (also the middleware name).
+ * @param value - the value to inject, or a factory `(io) => value` re-run per
+ *   invocation (may be async). A **callable** `value` is treated as a factory — to
+ *   inject a bare function as the value, wrap it: `provide('fn', () => myFn)`.
+ *
+ * @example
+ * ```ts
+ * const services = provide('services', { db, mailer });        // shared.ts / spec
+ * export const api = spec({ endpoints: { ...services.group({ sendInvite }) } });
+ * implement(api).middleware(services);                          // server.ts (bind once)
+ * // handler: ({ services }) => services.mailer.send(…)
+ * ```
+ */
+declare function provide<const N extends string, V>(name: N, value: V | ((io: MiddlewareIO<EmptyObject>) => V | Promise<V>)): ProvideMiddleware<N, V>;
+/**
+ * Middleware-level OpenAPI contributions, applied to every operation whose chain
+ * includes the middleware.
+ */
+interface MiddlewareDoc {
+  /** Named security schemes — merged into `components.securitySchemes` and required on each op. */
+  readonly security?: Readonly<Record<string, Json>>;
+  /** Patch applied to every operation whose chain includes this middleware. */
+  readonly openapi?: (op: Record<string, Json>) => Record<string, Json>;
+}
+/**
+ * Expand `requires` (auto-include) and topologically order a middleware list.
+ *
+ * `requires` edges pull dependencies in and force them earlier; `optional` edges
+ * only reorder middleware that are *already present*. Throws on a dependency
+ * cycle.
+ *
+ * @internal
+ */
+//#endregion
+//#region src/endpoint.d.ts
+/** Endpoint-level OpenAPI metadata, plus an escape hatch over the generated operation. */
+interface EndpointDoc {
+  readonly summary?: string;
+  readonly description?: string;
+  readonly tags?: readonly string[];
+  readonly deprecated?: boolean;
+  readonly operationId?: string;
+  /** Final say over this endpoint's generated operation object. */
+  readonly openapi?: (op: Record<string, Json>) => Record<string, Json>;
+}
+/** Event-level AsyncAPI metadata, plus an escape hatch over the generated channel. */
+interface EventDoc {
+  readonly summary?: string;
+  readonly description?: string;
+  /** Final say over this event's generated channel object. */
+  readonly asyncapi?: (channel: Record<string, Json>) => Record<string, Json>;
+}
+/** Spec-level final patches over the whole generated documents. */
+interface SpecDoc {
+  readonly openapi?: (doc: Record<string, Json>) => Record<string, Json>;
+  readonly asyncapi?: (doc: Record<string, Json>) => Record<string, Json>;
+}
+/** Options for a `Set-Cookie` written via the handler's `cookie()`. */
+interface CookieOptions {
+  readonly path?: string;
+  readonly domain?: string;
+  readonly maxAge?: number;
+  readonly expires?: Date;
+  readonly httpOnly?: boolean;
+  readonly secure?: boolean;
+  readonly sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/**
+ * The declarative configuration for one endpoint.
+ *
+ * Schemas are the single source of truth: each kind below contributes typed keys
+ * to the endpoint's single `data` payload (path params, query, body, files), and
+ * the kinds must be disjoint. Streaming, multi-status, typed errors, custom
+ * method/path, and documentation are all declared here.
+ */
+interface EndpointConfig {
+  /** Path params as a `z.object`; keys must be positioned in the path. */
+  readonly params?: z.ZodType;
+  /** Query params as a `z.object`. */
+  readonly query?: z.ZodType;
+  /** Request body — a `z.object` (merges into `data`) or any other schema (then it *is* `data`). */
+  readonly body?: z.ZodType;
+  /** Multipart file fields, keyed by form-field name. Declaring files forces `httpOnly`. */
+  readonly files?: Readonly<Record<string, z.ZodType>>;
+  /** Typed request headers (`z.object`, lowercase keys) — handler gets `headers`; never merged into `data`. */
+  readonly headers?: z.ZodType;
+  /** Typed request cookies (`z.object`) — handler gets `cookies`; server-side input only. */
+  readonly cookies?: z.ZodType;
+  /** Single success response schema. */
+  readonly response?: z.ZodType;
+  /** Multi-status success responses by code — handler returns `{ status, data }`, client gets a `{ status, data }` union. */
+  readonly responses?: Readonly<Record<number, z.ZodType>>;
+  /** Declared error responses by status — documents them and types the handler's `fail()`. */
+  readonly errors?: Readonly<Record<number, z.ZodType>>;
+  /** Body wire encoding (default `'json'`); `'urlencoded'` for `application/x-www-form-urlencoded` HTML forms. */
+  readonly bodyEncoding?: 'json' | 'urlencoded';
+  /** Typed item-stream output encoding (default `'ndjson'`); `'sse'` for `text/event-stream`. */
+  readonly streamEncoding?: 'ndjson' | 'sse';
+  readonly doc?: EndpointDoc;
+  /** HTTP method (default `POST`). */
+  readonly method?: HttpMethod;
+  /** Custom path: a `:key` string, or a {@link path} template whose schemas join the params kind. */
+  readonly path?: string | AnyPathTemplate;
+  /** Explicit WebSocket id (default: the un-injected url pattern + method). */
+  readonly ws?: string;
+  /** Force the endpoint to be HTTP-only (no ws). */
+  readonly httpOnly?: boolean;
+  /**
+   * Streaming request body. `string` → raw byte stream with that content-type
+   * (`stream: ReadableStream<Uint8Array>`); zod schema → typed NDJSON item stream
+   * (client passes an async iterable as `stream`, handler for-awaits validated items).
+   */
+  readonly streamIn?: string | z.ZodType;
+  /**
+   * Streaming response. `string` → raw byte stream with that content-type
+   * (handler returns/pipes bytes); zod schema → typed item stream over
+   * NDJSON/SSE (handler is an async generator, client `for await`s typed items).
+   */
+  readonly streamOut?: string | z.ZodType;
+  /** Raw `streamOut` only: serve with `Content-Disposition: attachment; filename="…"`. */
+  readonly download?: string;
+}
+/** Erased (non-generic) endpoint shape used by the runtime. @internal */
+interface AnyEndpoint {
+  readonly kind: 'endpoint';
+  readonly cfg: EndpointConfig;
+  readonly mws: readonly AnyMiddleware[];
+  readonly prefixes: ReadonlyArray<string | AnyPathTemplate>;
+  readonly __ctx: object;
+  readonly __lp: object;
+}
+/**
+ * A fully-typed endpoint declaration.
+ *
+ * @typeParam C   - the literal {@link EndpointConfig}.
+ * @typeParam Ctx - middleware-provided context visible to the handler.
+ * @typeParam LP  - loader-param schemas in scope.
+ * @typeParam PFX - prefix-param schemas in scope.
+ */
+interface Endpoint<C extends EndpointConfig, Ctx extends object, LP extends object, PFX extends object> extends AnyEndpoint {
+  readonly cfg: C;
+  readonly __ctx: Ctx;
+  readonly __lp: LP;
+  readonly __pfx: PFX;
+}
+/**
+ * Define a bare endpoint with no middleware.
+ *
+ * @example
+ * ```ts
+ * const getReport = endpoint({
+ *   method: 'GET',
+ *   path: reportPath,
+ *   response: z.object({ year: z.number(), slug: z.string() }),
+ * })
+ * ```
+ */
+declare function endpoint<const C extends EndpointConfig>(cfg: C & CheckCfg<C, EmptyObject, EmptyObject>): Endpoint<C, EmptyObject, EmptyObject, EmptyObject>;
+/** Extract `:key` param names from a literal path string. */
+type PathParamKeys<P extends string> = P extends `${string}:${infer R}` ? R extends `${infer K}/${infer Rest}` ? K | PathParamKeys<`/${Rest}`> : R : never;
+/** Keys of a `z.object` schema's input type. */
+type ZKeys<T> = T extends z.ZodType ? keyof z.input<T> & string : never;
+/** Param keys contributed by a `path` template attached to `cfg.path`. */
+type CfgTplKeys<C extends EndpointConfig> = Get<C, 'path'> extends {
+  readonly __ps: infer PS;
+} ? keyof PS & string : never;
+/** Every path-param key, from every source: `cfg.params`, loaders, prefix templates, own template/string. */
+type AllParamKeys<C extends EndpointConfig, LP extends object, PFX extends object> = ZKeys<Get<C, 'params'>> | (keyof LP & string) | (keyof PFX & string) | CfgTplKeys<C> | (Get<C, 'path'> extends string ? PathParamKeys<Get<C, 'path'>> : never);
+/** Keys of an object body (empty for a non-object body). */
+type BodyKeys<C extends EndpointConfig> = Get<C, 'body'> extends z.ZodType ? z.input<Get<C, 'body'> & z.ZodType> extends Record<string, unknown> ? keyof z.input<Get<C, 'body'> & z.ZodType> & string : never : never;
+/** Whether the body is a non-object (so it *is* the data payload). */
+type CfgHasRawBody<C extends EndpointConfig> = Get<C, 'body'> extends z.ZodType ? z.input<Get<C, 'body'> & z.ZodType> extends Record<string, unknown> ? false : true : false;
+/**
+ * Definition-time config validation, surfaced as compile errors that land on the
+ * offending config property.
+ *
+ * Enforces:
+ * - a custom path may only reference declared param keys;
+ * - each param key is declared exactly once (own template vs prefix vs `params`);
+ * - kinds are disjoint: query ∉ path, body ∉ path∪query, files ∉ path∪query∪body;
+ * - a non-object body excludes params/query/files (it *is* the data).
+ *
+ * Errors are emitted as `readonly ['message', Keys]` tuples (not plain strings)
+ * so that conflicting messages on the same property don't collapse to `never`.
+ * Cross-prefix position coverage is additionally validated at `spec()` time.
+ */
+type CheckCfg<C extends EndpointConfig, LP extends object, PFX extends object> = (Get<C, 'path'> extends string ? [PathParamKeys<Get<C, 'path'>>] extends [ZKeys<Get<C, 'params'>> | (keyof LP & string) | (keyof PFX & string)] ? EmptyObject : {
+  readonly path: readonly ['custom path references undeclared param keys:', Exclude<PathParamKeys<Get<C, 'path'>>, ZKeys<Get<C, 'params'>> | (keyof LP & string) | (keyof PFX & string)>];
+} : EmptyObject) & ([CfgTplKeys<C> & (keyof PFX | keyof LP | ZKeys<Get<C, 'params'>>)] extends [never] ? EmptyObject : {
+  readonly path: readonly ['path template re-declares param keys:', CfgTplKeys<C> & (keyof PFX | keyof LP | ZKeys<Get<C, 'params'>>) & string];
+}) & ([ZKeys<Get<C, 'params'>> & (keyof PFX | keyof LP)] extends [never] ? EmptyObject : {
+  readonly params: readonly ['params re-declares keys owned by a loader or prefix:', ZKeys<Get<C, 'params'>> & (keyof PFX | keyof LP) & string];
+}) & ([ZKeys<Get<C, 'query'>> & AllParamKeys<C, LP, PFX>] extends [never] ? EmptyObject : {
+  readonly query: readonly ['query keys collide with path params:', ZKeys<Get<C, 'query'>> & AllParamKeys<C, LP, PFX>];
+}) & ([BodyKeys<C> & (AllParamKeys<C, LP, PFX> | ZKeys<Get<C, 'query'>>)] extends [never] ? EmptyObject : {
+  readonly body: readonly ['body keys collide with path/query:', BodyKeys<C> & (AllParamKeys<C, LP, PFX> | ZKeys<Get<C, 'query'>>)];
+}) & ([(keyof Get<C, 'files'> & string) & (AllParamKeys<C, LP, PFX> | ZKeys<Get<C, 'query'>> | BodyKeys<C>)] extends [never] ? EmptyObject : {
+  readonly files: readonly ['files keys collide with path/query/body:', (keyof Get<C, 'files'> & string) & (AllParamKeys<C, LP, PFX> | ZKeys<Get<C, 'query'>> | BodyKeys<C>)];
+}) & (CfgHasRawBody<C> extends true ? [AllParamKeys<C, LP, PFX> | ZKeys<Get<C, 'query'>> | (keyof Get<C, 'files'> & string)] extends [never] ? EmptyObject : {
+  readonly body: readonly ['a non-object body is the entire data payload — params/query/files are not allowed alongside it'];
+} : EmptyObject);
+/** Configuration for a server-pushed event channel. */
+interface EventConfig {
+  /** Channel params as a `z.object` — subscriptions are keyed by these. */
+  readonly params?: z.ZodType;
+  /** Event payload schema. */
+  readonly data: z.ZodType;
+  /** Middleware chain that must pass before a client may subscribe. */
+  readonly guard?: readonly AnyMiddleware[];
+  /** Explicit WebSocket channel id (default: the event name). */
+  readonly ws?: string;
+  readonly doc?: EventDoc;
+}
+/** The shape passed to {@link spec}. */
+interface SpecShape {
+  readonly endpoints: Readonly<Record<string, AnyEndpoint>>;
+  readonly events?: Readonly<Record<string, EventConfig>>;
+  readonly doc?: SpecDoc;
+}
+/** Any normalized spec. */
+type AnySpec = SpecShape;
+/** Extract the events record of a spec (or `{}` when it has none). */
+type EventsOf<S extends AnySpec> = S['events'] extends Readonly<Record<string, EventConfig>> ? S['events'] : EmptyObject;
+/**
+ * Finalize a set of endpoints + events into a spec, validating every endpoint at
+ * definition time.
+ *
+ * Beyond the compile-time {@link CheckCfg} guarantees, this performs runtime
+ * sanity checks (flag exclusivity, kind shapes) and full
+ * {@link normalizeEndpoint | path/coverage/disjointness} validation — throwing
+ * immediately on any violation so misconfiguration fails at module init.
+ *
+ * @returns the same spec object, now type-branded and validated.
+ */
+declare function spec<const S extends SpecShape>(spec: S): S;
+/**
+ * Global-registry symbol under which {@link spec} stashes its lazy
+ * {@link manifestFromSpec} builder. Global (`Symbol.for`) so consumers — notably
+ * the zod-free `client` — can read it off a spec value **without importing this
+ * module**, so a manifest-only bundle never pulls in the deriver or zod.
+ *
+ * @internal
+ */
+
+/**
+ * Derive the zod-free {@link Manifest} from a spec — exactly the routing data
+ * `app.manifest()` returns, computed purely from the endpoint/event definitions.
+ * Used by {@link server} and stamped (cached) onto every spec by {@link spec}, so
+ * {@link client} can take a spec directly.
+ *
+ * This runs the zod-bearing {@link normalizeEndpoint}, so importing it — or
+ * handing a spec to the client — brings zod into the bundle. Pass a prebuilt
+ * manifest instead to keep a frontend schema-free.
+ */
+declare function manifestFromSpec(spec: AnySpec): Manifest;
+/** Read the keys of a `z.object` schema, or `null` for any other (or absent) schema. @internal */
+
+/** The fully-resolved runtime description of one endpoint. @internal */
+interface NormalizedEp {
+  readonly name: string;
+  readonly def: AnyEndpoint;
+  readonly method: HttpMethod;
+  readonly parts: readonly PathPart[];
+  readonly path: string;
+  /** Explicit ws id only — the default ws identity is method + path pattern. */
+  readonly ws: string | null;
+  readonly wsEligible: boolean;
+  readonly httpOnly: boolean;
+  readonly streamInCt: string | null;
+  readonly itemsIn: boolean;
+  readonly streamOutCt: string | null;
+  readonly items: boolean;
+  readonly sse: boolean;
+  readonly multi: boolean;
+  readonly bodyEnc: 'json' | 'urlencoded' | null;
+  readonly p: readonly string[];
+  readonly q: readonly string[];
+  readonly b: readonly string[] | null;
+  readonly bRaw: boolean;
+  readonly f: readonly string[];
+  readonly loaders: ReadonlyMap<string, z.ZodType>;
+  /** Per-key schemas from own + prefix templates. */
+  readonly tplSchemas: ReadonlyMap<string, z.ZodType>;
+  readonly chain: readonly AnyMiddleware[];
+}
+/**
+ * Resolve an endpoint declaration into a {@link NormalizedEp}: assemble its path
+ * parts (prefixes → own path → default), verify exact-once param declaration and
+ * positioning, and enforce kind disjointness. Throws on any violation.
+ *
+ * @internal
+ */
+//#endregion
+//#region src/caller.d.ts
+/** Deterministic JSON (sorted keys) — the default cache key for a call's `data`. */
+declare const stableStringify: (value: unknown) => string;
+/** A synchronous key/value store backing a {@link ClientCache} (memory or a `Storage`). */
+interface KVStore {
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  delete(key: string): boolean;
+  keys(): Iterable<string>;
+}
+/** Where a cache persists: a built-in backend name or your own {@link KVStore}. */
+type CacheStoreSpec = 'memory' | 'session' | 'local' | KVStore;
+/** Options for {@link createClientCache}. */
+interface ClientCacheOptions {
+  /** Backend (default `'memory'`). `'local'`/`'session'` fall back to memory where `Storage` is unavailable (SSR). */
+  readonly store?: CacheStoreSpec;
+  /** Max entries before LRU eviction (default 500). */
+  readonly max?: number;
+  /** Default time-to-live in ms (per-`set` `ttl` overrides; omitted ⇒ no expiry). */
+  readonly ttl?: number;
+  /** Key namespace for a `Storage` backend (default `'ayepi:cache:'`). */
+  readonly prefix?: string;
+  /** Clock injection (tests). */
+  readonly now?: () => number;
+}
+/** What a {@link ClientCache.read} returns: the value plus whether it is fresh or stale (SWR). */
+interface CacheHit {
+  readonly value: unknown;
+  /** `true` when past `ttl` but within the stale-while-revalidate window. */
+  readonly stale: boolean;
+}
+/** A tag-aware LRU cache shared by a client's callers. */
+interface ClientCache {
+  /** Read a key — `undefined` when missing or fully expired (past the stale window). */
+  read(key: string): CacheHit | undefined;
+  /** Cache a JSON-serializable value (no-op for non-serializable values). */
+  write(key: string, value: unknown, opts?: {
+    ttl?: number;
+    staleWhileRevalidate?: number;
+    tags?: readonly string[];
+  }): void;
+  /** Remove one key. */
+  remove(key: string): void;
+  /** Remove every key matching `pred` (e.g. a caller's prefix). Returns the count removed. */
+  removeWhere(pred: (key: string) => boolean): number;
+  /** Remove every entry carrying any of `tags`. Returns the count removed. */
+  invalidateTags(tags: readonly string[]): number;
+  /** Drop everything. */
+  clear(): void;
+}
+/** Create a tag-aware LRU cache over the chosen backend. */
+declare function createClientCache(opts?: ClientCacheOptions): ClientCache;
+/** Shared per-client caller state: a cache per distinct store, with cross-store tag invalidation. */
+interface CallerContext {
+  /** The cache for a store spec (memoized; the default store when omitted). */
+  cacheFor(store: CacheStoreSpec | undefined): ClientCache;
+  /** Invalidate `tags` across **every** cache this client has created. */
+  invalidateTags(tags: readonly string[]): void;
+}
+/** Create the shared caller context. `defaults` seed each store's cache (`max`/`ttl`/`store`). */
+declare function createCallerContext(defaults?: ClientCacheOptions): CallerContext;
+/** Tags for a caller — a static list, or derived from the call's data (+ result, for invalidation). */
+type Tagger<E extends AnyEndpoint> = readonly string[] | ((data: ClientData<E>, result: unknown) => readonly string[]);
+/** Per-caller caching config (or `true` for defaults). */
+interface CallerCacheConfig<E extends AnyEndpoint> {
+  /** Entry time-to-live (ms); omitted ⇒ the client cache default (often no expiry). */
+  readonly ttl?: number;
+  /** Extra ms after `ttl` during which a stale value is served while it refetches in the background. */
+  readonly staleWhileRevalidate?: number;
+  /** Derive the cache key from the call's data (default: stable JSON of the data). */
+  readonly key?: (data: ClientData<E>) => string;
+  /** Tags attached to this caller's cached entries (for group invalidation). */
+  readonly tags?: Tagger<E>;
+  /** Which client cache to use (default the client's shared memory cache). */
+  readonly store?: CacheStoreSpec;
+}
+/** Per-caller debounce config (or a plain `wait` in ms). */
+interface CallerDebounceConfig<E extends AnyEndpoint> {
+  /** Quiet period before the trailing call fires (ms). */
+  readonly wait: number;
+  /** Force a call after at most this long since the first queued call (ms). */
+  readonly maxWait?: number;
+  /** Also fire immediately on the leading edge of a burst. */
+  readonly leading?: boolean;
+  /** Merge the data of every debounced call into one call's data. */
+  readonly accumulate?: (dataList: ClientData<E>[]) => ClientData<E>;
+  /** Fan the single accumulated result back to each queued caller (default: all get the same result). */
+  readonly spread?: (result: unknown, dataList: ClientData<E>[]) => unknown[];
+}
+/** Per-caller rate-limit config (token bucket). */
+interface CallerRateLimitConfig {
+  /** Bucket capacity (max calls per window). */
+  readonly limit: number;
+  /** Window/refill period (ms). */
+  readonly window: number;
+  /** Over budget: `'wait'` for a token (default), `'drop'` (reject), or `'throw'`. */
+  readonly onLimit?: 'wait' | 'drop' | 'throw';
+}
+/** Per-caller retry config — a lightweight exponential backoff (a client-side subset of `@ayepi/core`'s retry). */
+interface CallerRetryConfig {
+  /** Total tries including the first (default 3). */
+  readonly attempts?: number;
+  /** First backoff delay in ms (default 200). */
+  readonly base?: number;
+  /** Backoff growth multiplier (default 2). */
+  readonly factor?: number;
+  /** Maximum backoff delay in ms (default 30000). */
+  readonly max?: number;
+  /** Randomization fraction `0..1` subtracted from each delay (default 0.5). */
+  readonly jitter?: number;
+}
+/** Options for {@link ApiClient.caller}. Each enabled feature is applied as its own wrapper layer. */
+interface CallerOptions<E extends AnyEndpoint> {
+  /** Cache responses keyed by the call's data (TTL, tags, stale-while-revalidate, store). */
+  readonly cache?: boolean | CallerCacheConfig<E>;
+  /** Debounce rapid calls (with optional accumulation into one call). */
+  readonly debounce?: number | CallerDebounceConfig<E>;
+  /** Token-bucket rate limit. */
+  readonly rateLimit?: CallerRateLimitConfig;
+  /** Retry a failed call with exponential backoff ({@link CallerRetryConfig}). */
+  readonly retry?: CallerRetryConfig;
+  /** Only deliver the most recent call's response — supersede (abort) older in-flight calls. */
+  readonly lastOnly?: boolean;
+  /** Coalesce concurrent identical calls into one in-flight request. */
+  readonly dedupe?: boolean;
+  /** Tags this caller invalidates (clearing matching entries in **other** callers' caches). */
+  readonly invalidates?: Tagger<E>;
+  /** When to invalidate (`'success'` default). */
+  readonly invalidateOn?: 'success' | 'start' | 'both';
+  /** Fired when a call is admitted (before any wait). */
+  readonly onStart?: (data: ClientData<E>) => void;
+  /** Fired when a call resolves. */
+  readonly onSuccess?: (result: unknown, data: ClientData<E>) => void;
+  /** Fired when a call rejects. */
+  readonly onError?: (error: unknown, data: ClientData<E>) => void;
+  /** Fired when a call settles (either way). */
+  readonly onSettled?: (data: ClientData<E>) => void;
+}
+/** A configured caller for one endpoint — `call` applies the policy; plus control + status. */
+interface Caller<E extends AnyEndpoint> {
+  /** Invoke the endpoint through the policy layers (same arguments as `client.call`). */
+  call(...args: CallArgs<E>): CallReturn<E>;
+  /** Abort in-flight calls and drop any pending debounced calls. */
+  cancel(): void;
+  /** Clear this caller's own cached entries. */
+  invalidate(): void;
+  /** How many calls are currently in flight (awaiting a result, including debounce waits). */
+  readonly pending: number;
+}
+/** Rejected when a rate-limited caller is over budget with `onLimit: 'drop'`/`'throw'`. */
+declare class CallerRateLimited extends Error {
+  constructor(message?: string);
+}
+/** Loose view of the manifest endpoint the caller needs (kept structural to avoid a hard import). */
+//#endregion
+//#region src/client.d.ts
+/** A minimal ws transport the client drives: send a frame, receive frames. */
+interface ClientWs {
+  /** Send a serialized frame to the server. */
+  send(frame: string): void;
+  /** Register the handler the transport calls for each inbound frame. */
+  onMessage(cb: (frame: string) => void): void;
+}
+/** Options for {@link client}. */
+interface ClientOptions {
+  /** Base URL for HTTP requests (with or without a trailing slash). */
+  readonly baseUrl: string;
+  /**
+   * What the client routes from — either is accepted:
+   *
+   * - a zod-free {@link Manifest} (from `app.manifest()` / {@link manifestFromSpec}, e.g.
+   *   imported as a prebuilt value) — keeps a frontend bundle **schema-free**; or
+   * - the **spec** itself — convenient when slimming the bundle isn't a concern; the
+   *   client derives the manifest from it. Because the spec holds zod, this pulls zod
+   *   into the bundle.
+   *
+   * The slim path stays zod-free purely by tree-shaking: a manifest value carries no
+   * derivation code, and the spec's (zod-bearing) deriver is only reached when a spec is
+   * actually passed.
+   */
+  readonly manifest: Manifest | AnySpec;
+  /** Default headers, static or computed per request (e.g. a fresh auth token). */
+  readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+  /** Override `fetch` (tests / in-memory wiring). */
+  readonly fetchImpl?: (req: Request) => Promise<Response>;
+  /** Defaults for the per-client {@link caller} caches (`max`/`ttl`/default `store`). */
+  readonly cache?: ClientCacheOptions;
+  /** WebSocket transport; required for ws calls and event subscriptions. */
+  readonly ws?: ClientWs;
+  /** Preferred transport for dual endpoints (default `'http'`). */
+  readonly prefer?: 'http' | 'ws';
+  /**
+   * Opt-in client-side validation: pass the spec to parse responses/items with
+   * their zod schemas as they arrive. Omit to keep the frontend bundle zod-free
+   * (types still assert shapes statically).
+   */
+  readonly validate?: AnySpec;
+}
+/** Endpoint names addressable as a plain `GET` URL (browser navigation / `<a href>` / streamed downloads). */
+type GetUrlKeys<S extends AnySpec> = { [K in keyof S['endpoints']]: Get<S['endpoints'][K]['cfg'], 'method'> extends 'GET' ? K : never }[keyof S['endpoints']] & string;
+/** The typed client surface for a spec `S`. */
+interface ApiClient<S extends AnySpec> {
+  /** Call an endpoint. Arguments and return type are derived per endpoint. */
+  call<K extends keyof S['endpoints'] & string>(name: K, ...args: CallArgs<S['endpoints'][K]>): CallReturn<S['endpoints'][K]>;
+  /**
+   * A **caller**: `call` wrapped with stateful client-side policy — caching (TTL/tags/SWR/storage),
+   * debounce (with accumulation), rate limiting, last-response-only, in-flight dedupe, retry, and
+   * lifecycle hooks. Caches are shared across a client's callers, so a mutating caller's tag
+   * invalidation clears other callers' cached reads.
+   */
+  caller<K extends keyof S['endpoints'] & string>(name: K, options?: CallerOptions<S['endpoints'][K]>): Caller<S['endpoints'][K]>;
+  /**
+   * Build the full URL for a `GET` endpoint — hand it to the browser
+   * (`location`, `<a href>`, `window.open`) for natively stream-downloaded
+   * responses (e.g. zip exports declared with `download:`).
+   */
+  url<K extends GetUrlKeys<S>>(name: K, ...args: [keyof ClientData<S['endpoints'][K]>] extends [never] ? [] : [data: ClientData<S['endpoints'][K]>]): string;
+  /** Subscribe to a server-pushed event; returns an unsubscribe function. */
+  on<K extends keyof EventsOf<S> & string>(name: K, ...args: Get<EventsOf<S>[K] & EventConfig, 'params'> extends z.ZodType ? [params: z.input<Get<EventsOf<S>[K] & EventConfig, 'params'> & z.ZodType>, cb: (data: z.output<(EventsOf<S>[K] & EventConfig)['data']>) => void] : [cb: (data: z.output<(EventsOf<S>[K] & EventConfig)['data']>) => void]): () => void;
+}
+/**
+ * Create a typed client from a {@link Manifest}.
+ *
+ * @typeParam S - the spec type, used purely for inference (no runtime schemas).
+ *
+ * @example
+ * ```ts
+ * const sdk = client<typeof api>({ baseUrl, manifest, ws })
+ * const user = await sdk.call('getUser', { id: 'u1' })       // fully typed
+ * for await (const row of sdk.call('streamRows', { n: 4 })) … // typed item stream
+ * const off = sdk.on('jobProgress', { jobId }, (d) => …)     // typed event
+ * ```
+ */
+declare function client<S extends AnySpec>(opts: ClientOptions): ApiClient<S>;
+//#endregion
+//#region src/ws-transport.d.ts
+/** A message-ish event from a `WebSocket` (only `data` is read). */
+interface WsMessageEvent {
+  readonly data?: unknown;
+}
+/** The minimal `WebSocket` surface this transport drives. */
+interface WebSocketLike {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  addEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: WsMessageEvent) => void): void;
+}
+/** A `WebSocket` constructor (the global one, or `ws` in Node). */
+type WebSocketCtor = new (url: string, protocols?: string | string[]) => WebSocketLike;
+/** Connection state surfaced by {@link WsTransport.state} and `onStateChange`. */
+type WsState = 'closed' | 'connecting' | 'open';
+/** Reconnect backoff tuning. Delay for attempt `n` is `min(max, initial * factor^n)`, optionally jittered. */
+interface BackoffOptions {
+  /** First retry delay (default 500 ms). */
+  readonly initial?: number;
+  /** Maximum retry delay (default 30 000 ms). */
+  readonly max?: number;
+  /** Growth factor per attempt (default 2). */
+  readonly factor?: number;
+  /** Apply random jitter in `[delay/2, delay]` (default `true`). */
+  readonly jitter?: boolean;
+}
+/** Heartbeat tuning. */
+interface HeartbeatOptions {
+  /** How often to send `{ ping: true }` (default 30 000 ms). */
+  readonly interval?: number;
+  /** How long to wait for `{ pong: true }` before force-reconnecting (default 10 000 ms). */
+  readonly timeout?: number;
+}
+/** Options for {@link wsTransport}. */
+interface WsTransportOptions {
+  /**
+   * Subprotocols passed to the `WebSocket` constructor — a fixed value, or a
+   * function **resolved at each (re)connect**. Use the function form to carry a
+   * value that changes over time (e.g. an auth token as a subprotocol).
+   */
+  readonly protocols?: string | string[] | (() => string | string[] | undefined);
+  /** `WebSocket` constructor to use (defaults to the global `WebSocket`; pass `ws` in Node). */
+  readonly WebSocket?: WebSocketCtor;
+  /** What to do with non-subscription frames sent while disconnected (default `'fail'`). */
+  readonly whileDisconnected?: 'queue' | 'fail';
+  /** Reconnect backoff tuning. */
+  readonly backoff?: BackoffOptions;
+  /** Heartbeat tuning, or `false` to disable (default enabled). */
+  readonly heartbeat?: HeartbeatOptions | false;
+  /** Give up after this many consecutive failed reconnects (default `Infinity`). */
+  readonly maxRetries?: number;
+  /** Notified on every connection-state change. */
+  readonly onStateChange?: (state: WsState) => void;
+  /** Notified on socket/construction errors. */
+  readonly onError?: (error: unknown) => void;
+}
+/** A {@link ClientWs} with explicit lifecycle control. */
+interface WsTransport extends ClientWs {
+  /** Open the connection now (otherwise it opens lazily on first `send`). */
+  connect(): void;
+  /** Close permanently and stop reconnecting. */
+  close(): void;
+  /** Current connection state. */
+  readonly state: WsState;
+}
+/**
+ * Create a resilient {@link WsTransport} for {@link client}'s `ws` option.
+ *
+ * @param url  - the WebSocket URL (e.g. `wss://host/ws`), or a function returning
+ *   it. The function form is **resolved at each (re)connect**, so it's the place
+ *   to inject auth that isn't known up front — e.g. a token as a query param:
+ *   `wsTransport(() => \`wss://host/ws?access_token=${getToken()}\`)`. (Browsers
+ *   can't set headers on a ws handshake, so the token rides the URL or a subprotocol.)
+ * @param opts - reconnect / heartbeat / policy tuning.
+ */
+declare function wsTransport(url: string | (() => string), opts?: WsTransportOptions): WsTransport;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * # Errors
+ *
+ * The error envelope used on both sides of the wire. This module is deliberately
+ * **zod-free** so it can be imported by the browser client without pulling zod
+ * into the bundle.
+ *
+ * @module
+ */
+/**
+ * A transport-level API error.
+ *
+ * Thrown server-side to short-circuit a request with a status + machine code,
+ * and re-constructed client-side from an HTTP error envelope (`{ error: { code,
+ * message } }`) or a ws response frame whose `$status` is not 2xx (`$error`/`$code`
+ * + an optional typed `data` body), so the same `instanceof ApiError` check works
+ * everywhere.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sdk.call('getUser', { id: 'nope' })
+ * } catch (err) {
+ *   if (err instanceof ApiError && err.status === 404) showNotFound()
+ * }
+ * ```
+ */
+declare class ApiError extends Error {
+  readonly status: number;
+  readonly code: string;
+  readonly data?: unknown | undefined;
+  /**
+   * @param status  HTTP (or ws-mapped) status code.
+   * @param code    Stable machine-readable error code (e.g. `'UNAUTHORIZED'`).
+   * @param message Optional human-readable message; defaults to `code`.
+   * @param data    Optional structured payload — the parsed error body for
+   *                declared typed errors, or the raw envelope otherwise.
+   */
+  constructor(status: number, code: string, message?: string, data?: unknown | undefined);
+}
+/**
+ * Internal control-flow signal thrown by a handler's `fail()`.
+ *
+ * Carries an **already-validated** declared-error body so the server can emit it
+ * verbatim with the declared status. Not part of the public surface.
+ *
+ * @internal
+ */
+
+/**
+ * Construct an {@link ApiError} to `throw` from a handler or middleware.
+ *
+ * @example
+ * ```ts
+ * const auth = middleware('auth', async (io) => {
+ *   if (!io.req.headers.get('authorization')) throw reject(401, 'UNAUTHORIZED')
+ *   return io.next()
+ * })
+ * ```
+ */
+declare function reject(status: number, code: string, message?: string): ApiError;
+//#endregion
+export { LoaderImplFor as $, PathTemplate as $t, Tagger as A, server as At, EndpointDoc as B, EmitArgs as Bt, CallerOptions as C, LocalClient as Ct, ClientCache as D, WsConn as Dt, CallerRetryConfig as E, ServerOptions as Et, AnySpec as F, CallArgs as Ft, SpecShape as G, HandlerReturn as Gt, EventDoc as H, FailFn as Ht, CheckCfg as I, CallOpts as It, spec as J, UploadProgress as Jt, endpoint as K, IsHttpOnly as Kt, CookieOptions as L, CallOptsBase as Lt, createClientCache as M, asyncapiHtml as Mt, stableStringify as N, redocHtml as Nt, ClientCacheOptions as O, implement as Ot, AnyEndpoint as P, swaggerHtml as Pt, LoaderFn as Q, PathPart as Qt, Endpoint as R, CallReturn as Rt, CallerDebounceConfig as S, LocalCallOptions as St, CallerRateLimited as T, Server as Tt, EventsOf as U, HandlerFor as Ut, EventConfig as V, EmitFn as Vt, SpecDoc as W, HandlerPayload as Wt, BoundMiddleware as X, localBroker as Xt, AnyMiddleware as Y, Broker as Yt, ImplFor as Z, AnyPathTemplate as Zt, CacheHit as _, middleware as _t, WebSocketCtor as a, HttpMethod as an, MiddlewareIO as at, CallerCacheConfig as b, CorsOptions as bt, WsState as c, ManifestEvent as cn, Provide as ct, wsTransport as d, Stack as dt, buildParts as en, Middleware as et, ApiClient as f, StackCtx as ft, client as g, ctx as gt, GetUrlKeys as h, WsFrameInfo as ht, HeartbeatOptions as i, splitPattern as in, MiddlewareFn as it, createCallerContext as j, DocsOptions as jt, KVStore as k, localClient as kt, WsTransport as l, ProvideMiddleware as lt, ClientWs as m, Transport as mt, reject as n, matchParts as nn, MiddlewareDoc as nt, WebSocketLike as o, Manifest as on, MiddlewareImplFor as ot, ClientOptions as p, StackLP as pt, manifestFromSpec as q, StreamBody as qt, BackoffOptions as r, path as rn, MiddlewareFactory as rt, WsMessageEvent as s, ManifestEndpoint as sn, MiddlewareResult as st, ApiError as t, joinPattern as tn, MiddlewareDef as tt, WsTransportOptions as u, RouteInfo as ut, CacheStoreSpec as v, provide as vt, CallerRateLimitConfig as w, MountHandle as wt, CallerContext as x, Implementor as xt, Caller as y, use as yt, EndpointConfig as z, ClientData as zt };