@yolk-sdk/emulators 0.1.0-canary.96

package/dist/stateful-emulator.d.mts

@@ -0,0 +1,565 @@
+import { EmulatorEvidence, EmulatorRouteEvidence } from "./route-evidence.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/stateful-emulator.d.ts
+declare const NotEmulated_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => Readonly<A> & {
+  readonly _tag: "NotEmulated";
+} & import("effect/Pipeable").Pipeable;
+/** A request the emulator does not emulate, with the reason (answered 400 not-emulated). */
+declare class NotEmulated extends NotEmulated_base<{
+  readonly reason: string;
+}> {}
+declare const DecodedViewRefusal_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "DecodedViewRefusal";
+} & Readonly<A>;
+/**
+ * What a route's decoded view throws to refuse a body with a reason of its own (fail-closed mode;
+ * see `StatefulRouteBinding.decodedViews`). `reason` must be one of the route's declared
+ * `viewRefusalReasons` (a constant the route owns, never derived from the request); `decoded` holds
+ * any text the view did decode cleanly, which is still checked for the bearer first.
+ */
+declare class DecodedViewRefusal extends DecodedViewRefusal_base<{
+  readonly reason: string;
+  readonly decoded: ReadonlyArray<string>;
+}> {}
+declare const notEmulated: (reason: string) => NotEmulated;
+declare const isNotEmulated: (value: unknown) => value is NotEmulated;
+declare const jsonResponse: (status: number, body: unknown, headers?: HeadersInit) => Response;
+/** The one answer for everything no fixture records. */
+declare const notEmulatedResponse: (reason: string) => Response;
+/**
+ * Optional fault filter; an omitted field matches every request. `method` is the HTTP method
+ * (never a manifest row's `RPC`). `path` is the raw request path (in resolved mode, the
+ * resolution's ledger path); ending in `*`, a prefix. `route` is a manifest row path, compared
+ * with the request's ledger route: the template of its matched route, or the manifest variant its
+ * route admitted it as (see `StatefulRouteBinding.variants`).
+ * A `route` that names no manifest row of the emulator could never match, so adding the fault
+ * rejects it (a route with variants is matched by its variant rows, never its template).
+ */
+declare const StatefulFaultMatch: Schema.Struct<{
+  readonly method: Schema.optionalKey<Schema.String>;
+  readonly path: Schema.optionalKey<Schema.String>;
+  readonly route: Schema.optionalKey<Schema.String>;
+}>;
+type StatefulFaultMatch = typeof StatefulFaultMatch.Type;
+/**
+ * A status fault: answer matching requests with this status (400-599), headers, and body before
+ * the route runs, so nothing is written. The body defaults to an emulator-fault body
+ * (`{ error: { type: 'emulator_fault', message } }`), never a guessed provider envelope. `count`
+ * limits how many requests it answers (omitted: all). `match.path` is the raw request path.
+ * Invalid header names or values, `location`, and framing headers are rejected.
+ */
+declare const StatefulFault: Schema.Struct<{
+  readonly kind: Schema.Literal<"status">;
+  readonly status: Schema.Int;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly method: Schema.optionalKey<Schema.String>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly route: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+}>;
+type StatefulFault = typeof StatefulFault.Type;
+/**
+ * Opt-in (`makeChunkedStatefulEmulator`): send the first `chunks` body chunks of the answer a
+ * streamed commit prepared (`StreamedCommit`), then close the body cleanly (a truncated answer).
+ * It is decided where a status fault is, after the plan, and a truncated request writes nothing:
+ * its `commit` never runs (no state, counter, or runtime change). One that cannot take effect (the
+ * answer is not streamed, or has no more than `chunks` chunks) answers the 500 emulator error and
+ * is not used up, never a silent no-op.
+ */
+declare const StatefulTruncateFault: Schema.Struct<{
+  readonly kind: Schema.Literal<"truncate-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly method: Schema.optionalKey<Schema.String>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly route: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+}>;
+type StatefulTruncateFault = typeof StatefulTruncateFault.Type;
+/** A status fault, or (`makeChunkedStatefulEmulator`) a truncation fault. */
+declare const StatefulStreamFault: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"status">;
+  readonly status: Schema.Int;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly method: Schema.optionalKey<Schema.String>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly route: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"truncate-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly method: Schema.optionalKey<Schema.String>;
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly route: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+}>]>;
+type StatefulStreamFault = typeof StatefulStreamFault.Type;
+type StatefulFaultState<Fault = StatefulFault> = {
+  readonly id: number;
+  readonly fault: Fault; /** Remaining matching requests; `undefined` for an unlimited fault. */
+  readonly remaining: number | undefined;
+  readonly applied: number;
+};
+type StatefulLedgerEntry = {
+  /** 1-based arrival order since the last ledger clear or reset. */readonly seq: number;
+  readonly method: string;
+  /**
+   * Raw request path; in fail-closed mode with guarded secrets scrubbed, in resolved mode the
+   * resolution's ledger path (scrubbed), and `/<unrecognised>` for an unrecognised request.
+   */
+  readonly path: string; /** Path template of the matched route. */
+  readonly route?: string; /** Query parameters; the values of credential-named keys are `<redacted>`. */
+  readonly query: Readonly<Record<string, string>>; /** Parsed JSON request body, with credential-named keys redacted at any depth. */
+  readonly body?: Schema.Json; /** Length of a raw (non-JSON) request body. */
+  readonly bodyBytes?: number;
+  /**
+   * The non-credential request headers the emulator records (lower-case names); a JSON header is
+   * recorded with credential-named keys redacted at any depth, or as `<redacted>` when unparseable.
+   */
+  readonly headers: Readonly<Record<string, string>>;
+  readonly status: number; /** Evidence of the matched route; `unknown-route` for requests on no route. */
+  readonly evidence: EmulatorEvidence | 'unknown-route'; /** Why the request was answered 400 not-emulated. */
+  readonly notEmulated?: string; /** Set when a fault answered the request (`truncate-after-chunks` cut its streamed body). */
+  readonly fault?: 'status' | 'truncate-after-chunks'; /** Set when the emulator could not build the response, or a route threw (answered 500). */
+  readonly responseError?: string;
+};
+type StatefulRouteCoverage = EmulatorRouteEvidence & {
+  /** Ledger requests on this route since the last ledger clear or reset. */readonly requests: number;
+};
+type StatefulCoverage = {
+  readonly routes: ReadonlyArray<StatefulRouteCoverage>; /** Ledger requests on no route. */
+  readonly unknownRouteRequests: number; /** Ledger requests answered 400 not-emulated (on a route or not). */
+  readonly notEmulatedRequests: number;
+};
+/**
+ * A ledger entry of an emulator built with `makeHeaderlessStatefulEmulator`, which records no
+ * request header and takes status faults only: the entry carries no `headers` field, no
+ * `bodyBytes` (it has no `bytes` routes), and only a `status` fault.
+ */
+type StatefulHeaderlessLedgerEntry = Omit<StatefulLedgerEntry, 'headers' | 'bodyBytes' | 'fault'> & {
+  /** Set when a fault answered the request. */readonly fault?: 'status';
+};
+/** One routed API request, as a route sees it. */
+type EmulatedRequest = {
+  readonly method: string; /** Raw (still percent-encoded) path; in resolved mode, the resolution's ledger path. */
+  readonly path: string;
+  /**
+   * Path parameters, percent-decoded once; in resolved mode (`resolveRequest`), the parameters the
+   * resolution supplies (never a credential).
+   */
+  readonly params: Readonly<Record<string, string>>;
+  readonly query: URLSearchParams;
+  /**
+   * The raw query (after `?`, before `#`, never decoded; `''` without one), as the wrapper saw it.
+   * Absent on a request built elsewhere (then `exactQuery`'s `rawNames` refuses any parameter).
+   */
+  readonly rawQuery?: string | undefined;
+  /**
+   * A non-credential request header (credential headers always read as `undefined`; in resolved
+   * mode, every header but `content-type` does).
+   */
+  readonly header: (name: string) => string | undefined;
+  /**
+   * The lower-case names of every request header, credential headers included (names only, never
+   * a credential value); none in resolved mode. Absent on a request built elsewhere.
+   */
+  readonly headerNames?: ReadonlyArray<string> | undefined; /** Parsed JSON body (`json` routes, and `json-or-empty` routes with a body). */
+  readonly json: Schema.Json | undefined; /** Raw body (`bytes` routes). */
+  readonly bytes: Uint8Array | undefined;
+  /**
+   * Fail-closed mode with `bearerDigest` only: the digest of the recognised bearer for the origin
+   * the request arrived on (never the bearer itself); `undefined` otherwise.
+   */
+  readonly bearerDigest?: string | undefined;
+};
+type RunContext<Env> = {
+  readonly env: Env; /** Ledger sequence number of the request (for synthetic request ids). */
+  readonly seq: number;
+};
+/** The writing part of an eligible request: applies its change and answers. */
+type Commit = () => Response;
+/** A streamed answer: its status, headers, and body chunks (sent one per pull). */
+type StreamedAnswer = {
+  readonly status: number;
+  readonly headers: Readonly<Record<string, string>>; /** The body chunks; none answers no body at all. */
+  readonly chunks: ReadonlyArray<string>;
+};
+/**
+ * A commit whose answer the plan prepares: `answer` is sent (one chunk per pull) only after
+ * `commit` has written the request's change. Because the answer exists before anything is
+ * written, the wrapper decides faults against it: a status fault or a `truncate-after-chunks`
+ * fault (`makeChunkedStatefulEmulator`) answers without running `commit`, so a faulted request
+ * writes nothing. `persisted` lists the texts `commit` will store (minted ids, for example), which
+ * the opt-in output guard (`guardOutput`) checks together with the answer.
+ */
+type StreamedCommit = {
+  readonly answer: StreamedAnswer;
+  readonly commit: () => void;
+  readonly persisted: ReadonlyArray<string>;
+};
+/** A streamed commit: the prepared `answer`, and the write (none by default) it commits. */
+declare const streamedCommit: (answer: StreamedAnswer, commit?: () => void, persisted?: ReadonlyArray<string>) => StreamedCommit;
+/** What a plan returns: a commit, a streamed commit, or not emulated. */
+type Planned = Commit | StreamedCommit | NotEmulated;
+/** An admitted request: its pure, state-reading eligibility check, returning the commit. */
+type Admission<State, Env> = {
+  readonly plan: (state: State, context: RunContext<Env>) => Planned;
+  /**
+   * The path of the manifest variant the request was admitted as (`StatefulRouteBinding.variants`):
+   * required when the route has variants, absent otherwise.
+   */
+  readonly variant?: string;
+};
+/**
+ * The body a route takes: none; JSON with an `application/json` media type; JSON of any media type
+ * or none (`json-or-empty`: an empty body is no body, any other must be valid JSON, and the route
+ * checks the media type itself); or raw bytes.
+ */
+type RouteBody = 'none' | 'json' | 'json-or-empty' | 'bytes';
+/** Route parts that are not evidence: the recorded origin and the raw parameter patterns. */
+type StatefulRouteBinding = {
+  /** The origin a fixture records the route on; another origin is not emulated. Omitted: any. */readonly origin?: string;
+  /**
+   * Raw (still percent-encoded) patterns of the path parameters; a parameter that does not match
+   * its pattern makes the path match no route. Fail-closed emulators give every parameter one.
+   */
+  readonly params?: Readonly<Record<string, RegExp>>;
+  /**
+   * Fail-closed mode only: texts the route derives from its raw body that the provider's wire
+   * format encodes in a way the percent and JSON closure cannot see through (for example base64url
+   * content). Each view is checked for the bearer like the raw body. A body that holds no such
+   * content yields no view. A view may throw to refuse a body whose encoded content it cannot
+   * check completely (for example content the route would refuse anyway); the request is then
+   * ledgered as the constant credential-repeat entry shape, before anything is recorded, a fault is
+   * decided, or anything is committed, with this reason:
+   *
+   * - `the request body repeats the credential` when the throw is a `DecodedViewRefusal` whose
+   *   cleanly `decoded` texts hold the bearer (a repeat, not a refusal);
+   * - otherwise its `reason` when that is one of `viewRefusalReasons` (scrubbed of the bearer,
+   *   defensively);
+   * - otherwise (an undeclared reason, or any other throw)
+   *   `the request body cannot be checked for the credential`.
+   *
+   * Omitted: none.
+   */
+  readonly decodedViews?: (body: string) => ReadonlyArray<string>;
+  /**
+   * The constant reasons a decoded view may refuse a body with (`DecodedViewRefusal`); any other
+   * reason is replaced by the uncheckable reason. Owned by the route, never derived from a request.
+   */
+  readonly viewRefusalReasons?: ReadonlyArray<string>;
+  /**
+   * Opt-in: the manifest rows this route answers INSTEAD of its own (for example one row per
+   * JSON-RPC method on one HTTP endpoint, `{ method: 'RPC', path: '<origin><path>#<method>' }`).
+   * Each admission names its row (`Admission.variant`), which becomes the request's ledger route,
+   * its coverage row, and what a fault's `match.route` compares; a request refused before it is
+   * admitted keeps the route's own template. Every variant carries the route's evidence, and no
+   * variant path repeats another manifest row or a route template (checked at build). Omitted:
+   * the route is its own manifest row, as before.
+   */
+  readonly variants?: ReadonlyArray<EmulatorRouteEvidence>;
+};
+type StatefulRoute<State, Env> = EmulatorRouteEvidence & StatefulRouteBinding & {
+  readonly body: RouteBody; /** The request-shape check (reads no state): an admission, or not emulated. */
+  readonly admit: (request: EmulatedRequest, env: Env) => Admission<State, Env> | NotEmulated;
+};
+/**
+ * A route of the table: its evidence (and recorded origin), the body it takes, its request-shape
+ * check `admit` (no state), and `plan`, which only ever sees an admitted input: it reads the state
+ * without writing and answers not emulated or the commit that writes.
+ */
+declare const statefulRoute: <State, Env, Input>(evidence: EmulatorRouteEvidence & StatefulRouteBinding, body: RouteBody, admit: (request: EmulatedRequest, env: Env) => Input | NotEmulated, plan: (state: State, input: Input, context: RunContext<Env>) => Planned) => StatefulRoute<State, Env>;
+/** Route evidence without the handler parts. */
+declare const routeEvidence: <State, Env>({
+  body: _body,
+  admit: _admit,
+  origin: _origin,
+  params: _params,
+  decodedViews: _decodedViews,
+  viewRefusalReasons: _viewRefusalReasons,
+  variants: _variants,
+  ...evidence
+}: StatefulRoute<State, Env>) => EmulatorRouteEvidence;
+/** The manifest rows of a route: its variants, or the route itself (`routeEvidence`). */
+declare const routeManifest: <State, Env>(route: StatefulRoute<State, Env>) => ReadonlyArray<EmulatorRouteEvidence>;
+/** A percent-decoded path segment, or `undefined` for invalid percent-encoding. */
+declare const decodeSegment: (segment: string) => string | undefined;
+type MatchedRoute<State, Env> = {
+  readonly route: StatefulRoute<State, Env>;
+  readonly params: Readonly<Record<string, string>>;
+};
+/**
+ * A matcher over a route table: the route answering `method` + raw `path`, with its parameters
+ * decoded once, or `undefined` (also for a parameter that is not valid percent-encoding). A raw
+ * parameter pattern must match the whole raw parameter; a pattern with the `g` or `y` flag (whose
+ * matches depend on earlier ones) is refused when the matcher is built.
+ */
+declare const routeMatcher: <State, Env>(routes: ReadonlyArray<StatefulRoute<State, Env>>) => (method: string, path: string) => MatchedRoute<State, Env> | undefined;
+/** The template parameters of a route that have no raw pattern (fail-closed emulators need one). */
+declare const unpatternedParams: <State, Env>(route: StatefulRoute<State, Env>) => ReadonlyArray<string>;
+/** Parsed JSON, or `undefined` for invalid JSON. */
+declare const parseJsonText: (text: string) => Schema.Json | undefined;
+declare const isJsonObject: (value: Schema.Json | undefined) => value is Schema.JsonObject;
+/**
+ * True when any object of a valid JSON text repeats a key, compared after JSON unescaping (so
+ * `"id"` and `"\u0069d"` are one key). `JSON.parse` would keep the last value silently.
+ */
+declare const repeatsJsonKey: (text: string) => boolean;
+/** The media type of a `content-type` value (lower-case, without parameters). */
+declare const mediaType: (value: string | undefined) => string;
+/**
+ * A JSON object with exactly the `required` keys plus any of the `optional` ones, or not
+ * emulated (naming the first missing or unknown key).
+ */
+declare const exactObject: (value: Schema.Json | undefined, label: string, required: ReadonlyArray<string>, optional?: ReadonlyArray<string>) => Schema.JsonObject | NotEmulated;
+/**
+ * Constant-text shape check (for fail-closed emulators): a JSON object with exactly the `required`
+ * keys plus any of the `optional` ones, or not emulated. Unlike `exactObject`, a reason never
+ * echoes a request's own key; it names only `label` and a missing key from the route's own list.
+ */
+declare const exactBodyKeys: (value: Schema.Json | undefined, label: string, required: ReadonlyArray<string>, optional?: ReadonlyArray<string>) => Schema.JsonObject | NotEmulated;
+/** Options of `exactQuery`. */
+type ExactQueryOptions = {
+  /**
+   * Opt-in: every raw parameter name (before `URLSearchParams` decodes it) must be written exactly
+   * as the route names it, so a percent-encoded or `+`-spaced spelling of an accepted name is not
+   * emulated. Omitted: names are compared decoded, as before.
+   */
+  readonly rawNames?: boolean;
+};
+/**
+ * Constant-text query check (for fail-closed emulators): exactly the `required` query keys plus
+ * any of the `optional` ones, each once, as a record of their values; or not emulated. A reason
+ * never echoes a request's own key; it names only a missing key from the route's own list. With
+ * `rawNames`, every raw parameter name must also be the plain name it decodes to.
+ */
+declare const exactQuery: (request: EmulatedRequest, required: ReadonlyArray<string>, optional?: ReadonlyArray<string>, options?: ExactQueryOptions) => Readonly<Record<string, string>> | NotEmulated;
+/** An integer in `[minimum, maximum]`, or not emulated. */
+declare const integerIn: (value: Schema.Json | undefined, label: string, minimum: number, maximum: number) => number | NotEmulated;
+/** Error-input kinds of the JS API. */
+type StatefulInputKind = 'seed' | 'fault' | 'option';
+/** The core runtime the Node subpath creates (state, snapshot, restore), as the wrapper uses it. */
+type StatefulCore<State> = {
+  readonly fetch: (request: Request) => Promise<Response>;
+  readonly baseUrl: string;
+  readonly snapshot: () => State;
+  readonly restore: (state: State) => Promise<void>;
+  readonly close: () => Promise<void>;
+};
+/**
+ * What the core runs for a request the wrapper forwarded: `(state, request)` to a response. The
+ * Node subpath registers it as the core app's only route.
+ */
+type CoreDispatch<State> = (state: State, request: Request) => Response;
+/** A request header the ledger records. */
+type RecordedHeader = {
+  readonly name: string;
+  readonly json: boolean;
+};
+/**
+ * Fail-closed mode: the constant reasons ledgered and answered for an unrecognised request (no
+ * emulated route shape) and for an unrecognisable `Authorization` header. Nothing the request
+ * carries is ledgered or answered for either.
+ */
+type StatefulFailClosed = {
+  readonly unrecognised: string;
+  readonly unrecognisedAuthorization: string;
+};
+/**
+ * Resolved mode: what the emulator's `resolveRequest` decides for one API request, failing closed.
+ *
+ * - `unrecognised`: the raw request matches no emulated route shape exactly (or its credential
+ *   cannot be extracted). It is ledgered and answered with constant text only
+ *   (`/<unrecognised>`, the method as sent when it is a standard one, else `<other>`, an empty
+ *   query, no headers or body, the constant `reason`).
+ * - `refused`: a recognised route refuses the request before its body is read (a missing
+ *   credential, a query key it does not take); the entry keeps the request's scrubbed fields.
+ * - `route`: a recognised request, handed to `route` with the credential-free `params`.
+ *
+ * For `refused` and `route`, `ledgerPath` is the path the ledger records (and a fault's
+ * `match.path` compares), with the credential already replaced by the emulator if the path carries
+ * it; `secrets` are the credential values the emulator took from the recognised shape (a path
+ * segment, a header), which the wrapper scrubs from everything it ledgers or answers and refuses
+ * to see repeated. `guardedPath` is the request text besides the query that must not repeat a
+ * secret (the path without the segment that carries the credential, for example).
+ */
+type StatefulResolution<State, Env> = {
+  readonly kind: 'unrecognised';
+  readonly reason: string;
+} | {
+  readonly kind: 'refused';
+  readonly route: StatefulRoute<State, Env>;
+  readonly ledgerPath: string;
+  readonly reason: string;
+  readonly secrets: ReadonlyArray<string>;
+} | {
+  readonly kind: 'route';
+  readonly route: StatefulRoute<State, Env>;
+  readonly params: Readonly<Record<string, string>>;
+  readonly ledgerPath: string;
+  readonly guardedPath: string;
+  readonly secrets: ReadonlyArray<string>;
+};
+/**
+ * The emulator-owned texts of its recovery answers
+ * (`{ error: { type: 'emulator_error', message } }`): `failed` when a response cannot be built or a
+ * route throws (500), `closed` after `close` (503), and `unhandled` when handling the request
+ * itself fails (500).
+ */
+type StatefulErrorTexts = {
+  readonly failed: string;
+  readonly closed: string;
+  readonly unhandled: string;
+};
+type StatefulEmulatorConfig<State, Env> = {
+  readonly routes: ReadonlyArray<StatefulRoute<State, Env>>;
+  readonly env: Env;
+  readonly initial: State; /** Decode and build a seed; a string is why it is invalid. */
+  readonly buildSeed: (input: unknown) => State | string; /** Header rules every request must meet (after the credential); a string is not emulated. */
+  readonly requestProblem?: (header: (name: string) => string | undefined) => string | undefined;
+  /**
+   * Non-credential request headers the ledger records (lower-case names). A `json` header is
+   * parsed and its credential-named keys redacted at any depth; an unparseable value is recorded
+   * as `<redacted>`. A credential header name is refused when the emulator is built.
+   */
+  readonly recordHeaders: ReadonlyArray<RecordedHeader>;
+  /**
+   * Opt-in fail-closed mode (see the module header): constant-text ledger entries for unrecognised
+   * requests and Authorization headers, and the bearer value guarded as a secret. Every route
+   * parameter must have a raw pattern (checked when the emulator is built).
+   */
+  readonly failClosed?: StatefulFailClosed;
+  /**
+   * Opt-in resolved mode (not with `failClosed`; checked when the emulator is built), for an
+   * emulator whose credential the wrapper cannot find by itself (a token in a path segment) or
+   * that has its own credential rules: the emulator resolves every API request itself
+   * (`StatefulResolution`) instead of the wrapper's route match and `Authorization` handling, and
+   * names the credential values to guard. The wrapper then records the resolution's ledger path
+   * and the query as sent (credential-named keys redacted), both scrubbed of the secrets, matches a
+   * fault's `match.path` against that ledger path, and refuses, before the request headers are
+   * checked or the body is parsed, a recognised request that repeats a secret: the raw query, the
+   * `guardedPath`, or the body, each raw or percent-decoded once (`repeatsSecret`), and a JSON body
+   * also in any key, string, or number once parsed and as it would be recorded
+   * (`jsonRepeatsSecret`). Those refusals keep the request's scrubbed fields and never record the
+   * body. Routes see the ledger path and no header names; fault answers and refusals are returned
+   * outside the core; `recordHeaders` must be empty (checked at build). See the module header.
+   * Omitted: the wrapper matches routes itself, as before.
+   */
+  readonly resolveRequest?: (request: Request, url: URL) => StatefulResolution<State, Env>;
+  /**
+   * Opt-in: the texts of the emulator's recovery answers (`StatefulErrorTexts`). Omitted: the
+   * default texts, as before.
+   */
+  readonly errorTexts?: StatefulErrorTexts;
+  /**
+   * Opt-in, fail-closed mode only (checked when the emulator is built): a one-way digest of a
+   * recognised bearer for the origin the request arrived on, handed to routes as
+   * `EmulatedRequest.bearerDigest`, never the bearer itself. A route compares it with digests its
+   * state holds (for example of the keys a seed marks as rejected on one origin), so a credential
+   * can change an answer without the bearer reaching the state, the ledger, or `/_emulate/*`.
+   * Taking the origin makes the digest per origin: one key gives different digests on two origins.
+   * A digest that throws or repeats the bearer (through the closure) answers the 500 emulator
+   * error before the route's shape check (no fault used, nothing written). Omitted: routes see no
+   * digest, as before.
+   */
+  readonly bearerDigest?: (bearer: string, origin: string) => string;
+  /**
+   * Opt-in, fail-closed mode only (checked at build): every refusal is ledgered with constant text
+   * only, like an unrecognised request (`/<unrecognised>`, a standard method or `<other>`, an
+   * empty query, no headers or body), keeping only its constant route (template or variant) and
+   * reason, so a ledger entry holds request text only once the route admitted the request. Route
+   * reasons must then be constants. Omitted: refusals keep the request's recorded fields, as
+   * before.
+   */
+  readonly constantRefusals?: boolean;
+  /**
+   * Opt-in, fail-closed mode only (checked at build): every request header other than
+   * `Authorization`, its name and its value, is checked for a credential repeat through the
+   * closure (not only the recorded headers), independently of what the ledger records; a repeat is
+   * refused with the constant credential-repeat entry (`a request header repeats the credential`).
+   * Omitted: only the recorded headers are checked, as before.
+   */
+  readonly guardAllHeaders?: boolean;
+  /**
+   * Opt-in, fail-closed mode only (checked at build): a recognised request's prepared output must
+   * not repeat its bearer. Every plan answers a `StreamedCommit` (a plain `Commit` answers the 500
+   * emulator error), and before any fault is decided or anything is committed, every answer header
+   * name and value, every answer chunk, and every `persisted` text are checked for the bearer
+   * through the closure; a hit is refused with the constant credential-repeat entry
+   * (`the answer would repeat the credential`), no fault used and nothing written. Routes still see
+   * only the bearer's digest. Omitted: answers are not checked, as before.
+   */
+  readonly guardOutput?: boolean;
+  /**
+   * Opt-in: a JSON body in which any object repeats a key (after JSON unescaping, so `"id"` and
+   * `"\u0069d"` are one key) is not emulated (`a JSON body with a repeated key is not emulated`),
+   * instead of `JSON.parse` keeping the last value. Omitted: the last value wins, as before.
+   */
+  readonly uniqueJsonKeys?: boolean; /** Clear runtime data (cursors) on reset and seed. */
+  readonly clearRuntime: () => void; /** Extra `/_emulate/state` fields (runtime data). */
+  readonly runtimeState: () => Schema.JsonObject; /** The `/_emulate/seed` answer for a new state. */
+  readonly seedSummary: (state: State) => Schema.JsonObject;
+  readonly inputInvalid: (input: StatefulInputKind, reason: string) => Error;
+};
+type StatefulEmulatorApi<State, Seed, Fault = StatefulFault, Entry = StatefulLedgerEntry> = {
+  /**
+   * The fetch handler (API routes and `/_emulate/*`); a request arrives on the origin of its URL.
+   * Never rejects.
+   */
+  readonly fetch: (request: Request) => Promise<Response>;
+  /**
+   * The fetch handler for requests that arrive on `origin` whatever their URL says (serve it on
+   * a loopback server behind `EmulatedHttpClient`, which rewrites the origin). Never rejects.
+   */
+  readonly fetchOn: (origin: string) => (request: Request) => Promise<Response>;
+  readonly ledger: {
+    readonly entries: () => ReadonlyArray<Entry>;
+    readonly clear: () => void;
+  };
+  readonly faults: {
+    /** Add a fault; throws the emulator's input-invalid error for an invalid fault. */readonly add: (fault: Fault) => StatefulFaultState<Fault>;
+    readonly list: () => ReadonlyArray<StatefulFaultState<Fault>>;
+    readonly clear: () => void;
+  }; /** Restore the current seed and clear the ledger, faults, and runtime data (cursors). */
+  readonly reset: () => Promise<void>;
+  /**
+   * Replace the state with a new seed, which becomes what `reset` restores (runtime data is
+   * cleared). Rejects with the emulator's input-invalid error for an invalid seed.
+   */
+  readonly seed: (seed: Seed) => Promise<void>; /** A deep copy of the current state. */
+  readonly snapshot: () => State;
+  readonly coverage: () => StatefulCoverage; /** Close the core runtime. Later requests answer 503. Idempotent. */
+  readonly close: () => Promise<void>;
+};
+/**
+ * Build the wrapper over a core runtime. `createCore` receives the dispatch the core must run for
+ * every request (its only route) and returns the runtime adapter. Faults are status faults only.
+ */
+declare const makeStatefulEmulator: <State, Env, Seed>(config: StatefulEmulatorConfig<State, Env>, createCore: (dispatch: CoreDispatch<State>) => Promise<StatefulCore<State>>) => Promise<StatefulEmulatorApi<State, Seed>>;
+/**
+ * `makeStatefulEmulator` for an emulator that records no request header (opt-in): it takes no
+ * `recordHeaders`, and its ledger entries carry no `headers` field
+ * (`StatefulHeaderlessLedgerEntry`). Faults are status faults only.
+ */
+declare const makeHeaderlessStatefulEmulator: <State, Env, Seed>(config: Omit<StatefulEmulatorConfig<State, Env>, "recordHeaders">, createCore: (dispatch: CoreDispatch<State>) => Promise<StatefulCore<State>>) => Promise<StatefulEmulatorApi<State, Seed, StatefulFault, StatefulHeaderlessLedgerEntry>>;
+/**
+ * `makeStatefulEmulator` that also takes `truncate-after-chunks` faults
+ * (`StatefulTruncateFault`), which cut a streamed answer (`StreamedCommit`). Opt-in: the other
+ * emulators keep status faults only.
+ */
+declare const makeChunkedStatefulEmulator: <State, Env, Seed>(config: StatefulEmulatorConfig<State, Env>, createCore: (dispatch: CoreDispatch<State>) => Promise<StatefulCore<State>>) => Promise<StatefulEmulatorApi<State, Seed, StatefulStreamFault>>;
+/** Throws `inputInvalid('option', ...)` unless every drill knob is a known boolean (or absent). */
+declare const checkBooleanDrills: (drills: object | undefined, knobs: ReadonlyArray<string>, inputInvalid: (input: StatefulInputKind, reason: string) => Error) => void;
+//#endregion
+export { Admission, Commit, CoreDispatch, DecodedViewRefusal, EmulatedRequest, ExactQueryOptions, MatchedRoute, NotEmulated, Planned, RecordedHeader, RouteBody, RunContext, StatefulCore, StatefulCoverage, StatefulEmulatorApi, StatefulEmulatorConfig, StatefulErrorTexts, StatefulFailClosed, StatefulFault, StatefulFaultMatch, StatefulFaultState, StatefulHeaderlessLedgerEntry, StatefulInputKind, StatefulLedgerEntry, StatefulResolution, StatefulRoute, StatefulRouteBinding, StatefulRouteCoverage, StatefulStreamFault, StatefulTruncateFault, StreamedAnswer, StreamedCommit, checkBooleanDrills, decodeSegment, exactBodyKeys, exactObject, exactQuery, integerIn, isJsonObject, isNotEmulated, jsonResponse, makeChunkedStatefulEmulator, makeHeaderlessStatefulEmulator, makeStatefulEmulator, mediaType, notEmulated, notEmulatedResponse, parseJsonText, repeatsJsonKey, routeEvidence, routeManifest, routeMatcher, statefulRoute, streamedCommit, unpatternedParams };
+//# sourceMappingURL=stateful-emulator.d.mts.map

package/dist/stateful-emulator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateful-emulator.d.mts","names":[],"sources":["../src/stateful-emulator.ts"],"mappings":"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"}