@demlik/tea 0.15.0 → 0.16.0

package/dist/{index-CA_7I5g9.d.ts → index-Cou86-GX.d.ts}

@@ -1,6 +1,6 @@
-import { a as CmdOf, b as CmdDef, i as NoCtx, C as Cmd } from './core-DnzqWy6u.js';
+import { c as CmdOf, b as CmdDef, g as TaggedError, r as MalformedResult, T as TimerDeps, C as Cmd } from './core-BbgtiXdg.js';
 import { RetryState, AnyRetryPolicy } from './retry-backoff/index.js';
-import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub, s as subscribeDeadline } from './index-HSYgG2Yt.js';
+import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-Xufl55W8.js';
 
 /**
  * @packageDocumentation
@@ -352,18 +352,18 @@ interface DeadlineConfig {
     readonly ms: number;
 }
 /**
- * The family every unnamed knob speaks: `resilient_run` / `resilient_ok` /
- * `resilient_err`. Identical to the `MsgType.Resilient*` literals, which stay
- * the vocabulary of every knob that passes no name.
+ * The family every unnamed knob speaks: `resilient_run` / `resilient_run_ok` /
+ * `resilient_run_err`. Identical to the `MsgType.Resilient*` literals, which
+ * stay the vocabulary of every knob that passes no name.
  */
 declare const DEFAULT_RESILIENT_NAME = "resilient";
 type DefaultResilientName = typeof DEFAULT_RESILIENT_NAME;
 /** The run Cmd's `type` for the `N` family. */
 type ResilientRunType<N extends string> = `${N}_run`;
-/** The success settle Msg's `type` for the `N` family. */
-type ResilientOkType<N extends string> = `${N}_ok`;
-/** The failure settle Msg's `type` for the `N` family. */
-type ResilientErrType<N extends string> = `${N}_err`;
+/** The success settle Msg's `type` for the `N` family — minted by the engine. */
+type ResilientOkType<N extends string> = `${N}_run_ok`;
+/** The failure settle Msg's `type` for the `N` family — minted by the engine. */
+type ResilientErrType<N extends string> = `${N}_run_err`;
 /**
  * The resilience knob. EVERY field is optional: omit a brick and its gate is
  * skipped entirely (the slice still carries a default brick state so the shape
@@ -375,12 +375,13 @@ type ResilientErrType<N extends string> = `${N}_err`;
  */
 interface ResilientConfig<N extends string = DefaultResilientName> {
     /**
-     * What this knob's Cmd and settle Msgs are called: `<name>_run`, `<name>_ok`,
-     * `<name>_err`. Omit it and the family is `resilient` — `resilient_run` /
-     * `resilient_ok` / `resilient_err`, exactly as before this parameter existed.
+     * What this knob's Cmd and settle Msgs are called: `<name>_run`, and the
+     * `<name>_run_ok` / `<name>_run_err` the engine mints from the run handler's
+     * outcome. Omit it and the family is `resilient` — `resilient_run` /
+     * `resilient_run_ok` / `resilient_run_err`.
      *
-     * Name a knob when a machine mounts more than one of the resilient family.
-     * Two unnamed knobs meet in ONE `resilient_ok` cell whose payload is the union
+     * Name a knob when a machine holds more than one of the resilient family.
+     * Two unnamed knobs meet in ONE `resilient_run_ok` cell whose payload is the union
      * of both results, and the consumer discriminates by hand on `key` — which the
      * type checker cannot see. Under distinct names each knob settles into its own
      * cell, already narrowed to its own payload.
@@ -398,7 +399,7 @@ interface ResilientConfig<N extends string = DefaultResilientName> {
      * wall-clock outage budget (`DurationRetryPolicy`), or explicit
      * `unbounded: true`. A duration bound needs no extra wiring: every path that
      * records a failure already holds the instant it was observed as DATA —
-     * `fail`'s `msg.at` (stamped at the interpret boundary) and `gate`'s `at`
+     * `settle`'s `msg.at` (stamped at the interpret boundary) and `gate`'s `at`
      * (the caller's `attempt` / the retry timer's `atMs`) — so the streak clock
      * is fed from a Msg, never from a `Date.now()` inside a verb (invariant 2).
      */
@@ -441,7 +442,7 @@ interface CallBudget {
  * `phase` so each phase carries only its own data (pattern 11):
  *
  *   - `idle`          — never attempted, or fully settled and forgotten.
- *   - `running`       — the effect Cmd is out; awaiting `succeed` / `fail`.
+ *   - `running`       — the effect Cmd is out; awaiting `settle`.
  *                       Carries the deadline budget ({@link CallBudget}) and the
  *                       last `input` so a retry can re-issue it.
  *   - `waiting_retry` — a transient failure backed off; the retry timer is armed
@@ -497,11 +498,28 @@ interface ResilientState<I, R> {
     readonly retry: Readonly<Record<string, RetryState>>;
     readonly cache: TtlCache<R>;
     readonly calls: Readonly<Record<string, CallPhase<I, R>>>;
+    /**
+     * The instant of the latest clocked transition this slice saw — the `at` of
+     * the last `attempt` / `resume` / `settleFailed`, settled Msg or timer fire.
+     * `timer` counts the soonest deadline down from it, so the built-in `timer`
+     * Sub gets a relative `ms` without anything reading a clock. `0` until the
+     * first clocked transition.
+     */
+    readonly clockMs: number;
 }
 /**
- * The one effect this knob emits: "run the port for `key` with `input`". The
- * consumer's `handlers(ports)` interprets it; it carries no closure — `input`
- * is plain data (invariant 3).
+ * The failures a run handler may return (ADR 0021). `port_rejected` is the
+ * work failing — carry the cause beside the tag (`err({ _tag: "port_rejected",
+ * cause })`); `deadline_exceeded` is a handler that timed the work out itself.
+ * Either one settles as `<name>_run_err` and feeds the retry / breaker. Any
+ * other failure is a contract breach and goes to the error sink.
+ */
+type RunErr = TaggedError<"port_rejected" | "deadline_exceeded">;
+/**
+ * The one effect this knob emits: "run the work for `key` with `input`". It is
+ * `Cmd.define`d, so the handler you write for it returns an outcome and the
+ * engine mints `<name>_run_ok` / `<name>_run_err` (ADR 0021). It carries no
+ * closure — `input` is plain data (invariant 3).
  */
 declare function runCmdDef<I, R, N extends string = DefaultResilientName>(name?: N): CmdDef<`${N}_run`, {
     readonly key: string;
@@ -512,37 +530,97 @@ declare function runCmdDef<I, R, N extends string = DefaultResilientName>(name?:
 } | {
     readonly [detail: string]: unknown;
     readonly _tag: "port_rejected";
-}, unknown>;
+}>;
 type RunCmdDef<I, R, N extends string = DefaultResilientName> = ReturnType<typeof runCmdDef<I, R, N>>;
-type RunCmd<I, N extends string = DefaultResilientName> = CmdOf<RunCmdDef<I, unknown, N>>;
 /**
- * Settle Msgs the `handlers` port dispatches back. `at` is stamped at the
- * boundary. Both are generic in the knob's name family `N`, so two knobs named
- * apart land in two `update` cells whose payloads are already narrowed — the
- * `key` switch a single shared cell forces is gone.
+ * The run Cmd value. `R` is its settle value — `unknown` reads any knob's run
+ * Cmd; the knob's own verbs emit it at their `R`, which is what lets a machine
+ * list `cmds: [rc.run]` and take the verbs' Cmds as its own.
  */
-type SucceedMsg<R, N extends string = DefaultResilientName> = {
+type RunCmd<I, N extends string = DefaultResilientName, R = unknown> = CmdOf<RunCmdDef<I, R, N>>;
+/**
+ * The settle Msgs the engine mints from a run handler's outcome:
+ * `<name>_run_ok` carrying the handler's `value`, `<name>_run_err` carrying its
+ * declared `error`. Each carries the run Cmd it settles (`cmd.key` names the
+ * call) and the `at` the engine stamped. Both are generic in the knob's name
+ * family `N`, so two knobs named apart land in two `update` cells whose
+ * payloads are already narrowed.
+ *
+ * They are the `SettledOk` / `SettledErr` pair `Cmd.define` mints, spelled out
+ * so a helper that folds the error into a richer type of its own (llm-call's
+ * `LlmErr`, jev-ask's `JevAskErr`) can hand `settle` its Msg with `E` widened.
+ */
+type SucceedMsg<R, N extends string = DefaultResilientName, I = unknown> = {
     readonly type: ResilientOkType<N>;
-    readonly key: string;
-    readonly result: R;
+    readonly cmd: RunCmd<I, N>;
+    readonly value: R;
     readonly at: number;
 };
-type FailMsg<N extends string = DefaultResilientName> = {
+type FailMsg<N extends string = DefaultResilientName, I = unknown, E = RunErr | MalformedResult> = {
     readonly type: ResilientErrType<N>;
-    readonly key: string;
+    readonly cmd: RunCmd<I, N>;
+    readonly error: E;
+    readonly at: number;
+};
+/**
+ * What `settle` reads off a settled Msg: the call's `key` (on `cmd`), the
+ * engine's `at`, and the handler's `value` or `error`. {@link SucceedMsg} and
+ * {@link FailMsg} are both one of these, so an engine-minted Msg passes
+ * straight in; a helper that settles from its own data (a fallback answer, a
+ * compaction summary) builds the record without inventing a whole run Cmd.
+ */
+type SettleMsg<R, N extends string = DefaultResilientName> = {
+    readonly type?: ResilientOkType<N>;
+    readonly cmd: {
+        readonly key: string;
+    };
+    readonly value: R;
+    readonly at: number;
+} | {
+    readonly type?: ResilientErrType<N>;
+    readonly cmd: {
+        readonly key: string;
+    };
     readonly error: unknown;
     readonly at: number;
 };
+/**
+ * How a settled call ended — the third thing `settle` hands back, and the only
+ * place the port's value can be read from.
+ *
+ *   - `done`     — the port answered; `value` is its result.
+ *   - `failed`   — no retry is left (or no retry brick); `error` is the last
+ *                  failure.
+ *   - `retrying` — backed off; the retry timer is armed and the call is still
+ *                  live.
+ */
+type SettleOutcome<R> = {
+    readonly kind: "done";
+    readonly value: R;
+} | {
+    readonly kind: "failed";
+    readonly error: unknown;
+} | {
+    readonly kind: "retrying";
+};
+/**
+ * What `settle` returns: the settled slice, the Cmds it emitted, and the
+ * {@link SettleOutcome}. One record, so the slice update and the result read
+ * cannot be split apart in a hand-wired `update` cell.
+ */
+interface SettleResult<I, R, N extends string = DefaultResilientName> {
+    readonly call: ResilientState<I, R>;
+    readonly cmds: readonly RunCmd<I, N, R>[];
+    readonly outcome: SettleOutcome<R>;
+}
 /**
  * The deadline Msg tag this knob's timers dispatch, derived from its name the
- * same way `<name>_ok` / `<name>_err` are. The DEFAULT family keeps the bare
- * `"deadline_exceeded"` literal — that is the tag every machine wired before
- * the name existed already handles, and `mountResilientCall` still returns a
- * `deadline_exceeded` cell for an unnamed knob.
+ * same way the settle Msgs are. The DEFAULT family keeps the bare
+ * `"deadline_exceeded"` literal.
  */
 type ResilientDeadlineType<N extends string = DefaultResilientName> = N extends DefaultResilientName ? "deadline_exceeded" : `${N}_deadline`;
 /**
- * The name the deadline Sub carries for the `N` family — `undefined` for the
+ * The name a deadline carries for the `N` family — `undefined` for the
  * default family (no name at all, so the bare literal is dispatched), the name
  * itself otherwise. One conditional, so the value and {@link
  * ResilientDeadlineType} can never disagree about which family is unnamed.
@@ -567,20 +645,6 @@ type DeadlineExceededError = {
     readonly id: string;
     readonly atMs: number;
 };
-/**
- * What `handlers(ports)` returns: the interpret cell for this knob's run Cmd,
- * under that Cmd's own name. A named knob contributes `<name>_run`, so two
- * knobs' handler records merge into one `interpret` without either shadowing
- * the other.
- */
-type ResilientHandlers<I, R, N extends string = DefaultResilientName> = {
-    readonly [K in ResilientRunType<N>]: (cmd: RunCmd<I, N>, ctx: NoCtx) => Promise<SucceedMsg<R, N> | FailMsg<N>>;
-};
-/** Ports the consumer supplies to `handlers`. */
-interface ResilientPorts<I, R> {
-    /** The fallible work this knob wraps. Throws on failure → routed to `fail`. */
-    readonly run: (input: I, key: string) => Promise<R>;
-}
 /**
  * Build a resilient-call knob from `config`. `rng` is injected for retry
  * jitter — pass a fixed `() => 0.5` in tests to pin backoff; defaults to
@@ -588,30 +652,39 @@ interface ResilientPorts<I, R> {
  * curried onto the factory rather than threaded through every verb so callers
  * spell the determinism choice once.
  *
- * Returns the uniform L2 knob contract. `I` is the port input type, `R` the
- * port result type. Consumers outside the package reach this through
- * `withResilience` (`../with-resilience`) — see the migration map at the top
- * of this module.
+ * Returns plain functions and the run Cmd def (ADR 0022) — see the module doc
+ * for the wiring. `I` is the work's input type, `R` its result type.
  */
 declare function createResilientCall<I, R, N extends string = DefaultResilientName>(config: ResilientConfig<N>, rng?: () => number): {
     name: N;
+    /** The `Cmd.define`d run Cmd; list it in the machine's `cmds`. */
+    run: CmdDef<`${N}_run`, {
+        readonly key: string;
+        readonly input: I;
+    }, R, {
+        readonly [detail: string]: unknown;
+        readonly _tag: "deadline_exceeded";
+    } | {
+        readonly [detail: string]: unknown;
+        readonly _tag: "port_rejected";
+    }>;
     init: () => ResilientState<I, R>;
-    attempt: (s: ResilientState<I, R>, key: string, input: I, at: number) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
+    attempt: (s: ResilientState<I, R>, key: string, input: I, at: number) => readonly [ResilientState<I, R>, readonly RunCmd<I, N, R>[]];
     resume: (s: ResilientState<I, R>, at: number) => ResilientState<I, R>;
-    succeed: (s: ResilientState<I, R>, key: string, msg: SucceedMsg<R, N>) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
-    fail: (s: ResilientState<I, R>, key: string, msg: FailMsg<N>) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
-    settleFailed: (s: ResilientState<I, R>, key: string, error: unknown) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
-    onTimer: (s: ResilientState<I, R>, msg: ResilientTimerMsg) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
-    subs: (s: ResilientState<I, R>) => readonly DeadlineSub<DeadlineNameOf<N>>[];
-    handlers: (ports: ResilientPorts<I, R>) => ResilientHandlers<I, R, N>;
+    settle: (s: ResilientState<I, R>, msg: SettleMsg<R, N>) => SettleResult<I, R, N>;
+    settleFailed: (s: ResilientState<I, R>, key: string, error: unknown, at: number) => readonly [ResilientState<I, R>, readonly RunCmd<I, N, R>[]];
+    onTimer: (slice: ResilientState<I, R>, msg: {
+        readonly id: string;
+        readonly atMs: number;
+    }) => readonly [ResilientState<I, R>, readonly RunCmd<I, N, R>[]];
+    deadlines: (s: ResilientState<I, R>) => readonly DeadlineSub<DeadlineNameOf<N>>[];
+    timer: (s: ResilientState<I, R>) => TimerDeps<ResilientTimerMsg<N>> | null;
 };
 /**
  * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the
  * slice lives at `state.resilience`. A convenience for the common single-slice
  * host; consumers with a differently-named field spread by hand. Pure — a thin
- * record rebuild, no clock / RNG. Under `withResilience` the wrapper owns
- * `model.$resilience`, so there is nothing to lift; this is for the embedded
- * slice consumers only.
+ * record rebuild, no clock / RNG.
  *
  * The record rebuild itself is `liftSlice` from the root door (#231) — this
  * stays as the named, pre-keyed convenience for the `state.resilience` field,
@@ -620,187 +693,5 @@ declare function createResilientCall<I, R, N extends string = DefaultResilientNa
 declare function liftResilience<S extends {
     resilience: ResilientState<I, R>;
 }, I, R, C extends Cmd>(state: S, result: readonly [ResilientState<I, R>, readonly C[]]): readonly [S, readonly C[]];
-/** What every verb of a knob in this family hands back. */
-type Settle<I, R> = readonly [
-    ResilientState<I, R>,
-    readonly RunCmd<I>[]
-];
-/**
- * The part of a resilient-call knob {@link mountResilientCall} needs. This knob
- * satisfies it, and so does every knob that delegates these verbs to it —
- * `internal/jev/ask` and `internal/llm-call` both do, which is why the mount is
- * written against the shape rather than against either door.
- *
- * `OkMsg` / `ErrMsg` are parameters rather than {@link SucceedMsg} /
- * {@link FailMsg} because an inheriting knob narrows them: jev-ask's `fail`
- * takes a `JevFailMsg` whose `error` is a typed `JevAskErr`, and a mount that
- * fixed the supertype would hand that verb a widened Msg.
- */
-interface MountableKnob<I, R, OkMsg, ErrMsg, Handlers, N extends string = DefaultResilientName> {
-    /**
-     * The Msg-name family this knob settles into — `<name>_ok` / `<name>_err`
-     * (#229). The mount reads it rather than assuming `resilient_*`, so a named
-     * knob mounts into the cells it actually emits; an unnamed one is
-     * `resilient`, so nothing a machine already spread changes.
-     */
-    readonly name: N;
-    init(): ResilientState<I, R>;
-    succeed(s: ResilientState<I, R>, key: string, msg: OkMsg): Settle<I, R>;
-    fail(s: ResilientState<I, R>, key: string, msg: ErrMsg): Settle<I, R>;
-    onTimer(s: ResilientState<I, R>, msg: ResilientTimerMsg<N>): Settle<I, R>;
-    subs(s: ResilientState<I, R>): readonly DeadlineSub<DeadlineNameOf<N>>[];
-    handlers(): Handlers;
-}
-/**
- * The consumer's half of a settle cell: fold the settled answer into the
- * machine's own Model.
- *
- * It is handed the Model the inherited verb ALREADY settled — the slice at
- * `slice` is the post-`succeed` / post-`fail` one — so the ordering that wedges
- * a call at `running` is not something this callback can express. It returns
- * the repo's universal cell shape so a fold that needs to chain an effect
- * (book the answer, then write it somewhere) returns that Cmd like any other
- * reducer cell would.
- */
-type SettleFold<Model, M, C extends Cmd> = (model: Model, msg: M) => readonly [Model, readonly C[]];
-/** One cell of the update fragment {@link mountResilientCall} returns. */
-type MountedCell<Model, M, I, C extends Cmd> = (model: Model, msg: M) => readonly [Model, readonly (RunCmd<I> | C)[]];
-/**
- * What to mount, and where. `slice` names the Model field the knob's state
- * lives on — a plain, readable field, per
- * [ADR 0015](../../../../.decisions/0015-hide-the-wiring-never-the-state.md):
- * the mount absorbs the assembly and hides none of the durable state.
- */
-interface MountConfig<Model, Slice extends string, I, R, AttemptType extends string, AttemptMsg, OkMsg, ErrMsg, C extends Cmd, N extends string = DefaultResilientName> {
-    /** The Model field carrying the knob's slice. */
-    readonly slice: Slice;
-    /**
-     * The cell that starts a call. Its shape is the one wiring point the mount
-     * cannot supply: each door's `attempt` takes its own arguments (jev-ask reads
-     * a key, a state and an instant; llm-call reads a request), and only the
-     * consumer knows which Msg field carries each. `run` is that one line.
-     */
-    readonly attempt: {
-        /** The Msg type that starts a call — the key the cell lands on. */
-        readonly on: AttemptType;
-        readonly run: (slice: ResilientState<I, R>, msg: AttemptMsg) => Settle<I, R>;
-    };
-    /** Fold a settled success into the Model. Omit and only the slice advances. */
-    readonly onOk?: SettleFold<Model, OkMsg, C>;
-    /** Fold a settled failure into the Model. Omit and only the slice advances. */
-    readonly onErr?: SettleFold<Model, ErrMsg, C>;
-    /**
-     * Fold a call the TIMER settled into the Model. This is the third failure
-     * class, and it never reaches {@link MountConfig.onErr}: a deadline fire
-     * settles `failed` inside the slice and emits no settle Msg, so without this
-     * callback a call that dies on its budget advances the slice and folds
-     * nothing — the shape that used to be a documented caveat.
-     *
-     * It runs once per call the knob's deadline cell moved INTO `failed`:
-     * the deadline fire itself, and the resumed retry whose gate found the
-     * budget spent. A plain backoff tick, a stale fire and an already-`failed`
-     * call fold nothing. `error` is the slice's own settled error — a
-     * {@link DeadlineExceededError} on the deadline path.
-     *
-     * Omit and only the slice advances, exactly as the other two do.
-     */
-    readonly onDeadline?: SettleFold<Model, DeadlineSettled<N>, C>;
-}
-/**
- * What {@link MountConfig.onDeadline} is handed: the one call the timer cell
- * just settled `failed`, named by its `key`, carrying the error the slice
- * settled with and the timer Msg that produced it. It is not a Msg the reducer
- * ever sees — no settle Msg exists for this failure class, which is the whole
- * reason the callback is here.
- */
-interface DeadlineSettled<N extends string = DefaultResilientName> {
-    /** The call key that settled. */
-    readonly key: string;
-    /** The error now on the slice — a {@link DeadlineExceededError} on the deadline path. */
-    readonly error: unknown;
-    /**
-     * The timer Msg whose fire settled it — this knob's own tag, so a fold on a
-     * knob named `jev` is handed a `jev_deadline` and one on an unnamed knob a
-     * `deadline_exceeded`.
-     */
-    readonly msg: ResilientTimerMsg<N>;
-}
-/**
- * The four fragments a consumer spreads into `defineMachine`. Together with
- * `init` they are the eight wiring points; none of them is optional at the type
- * level, so a consumer that mounts cannot omit `subscribe` (a backed-off retry
- * that never fires) or re-implement `interpret` as a dispatching handler.
- */
-interface MountedResilientCall<Model, Slice extends string, I, R, AttemptType extends string, AttemptMsg, OkMsg, ErrMsg, C extends Cmd, Handlers, N extends string = DefaultResilientName> {
-    /** The starting slice under its field name — spread into the machine's `init`. */
-    init(): {
-        readonly [K in Slice]: ResilientState<I, R>;
-    };
-    /**
-     * The three settle cells plus the attempt cell, to spread into `update`.
-     *
-     * The two settle keys are the knob's OWN Msg names (#229), so a knob built as
-     * `name: "jev"` mounts into `jev_ok` / `jev_err` and two named knobs in one
-     * machine spread into four distinct cells instead of colliding on one. An
-     * unnamed knob is `resilient`, so the keys read `resilient_ok` /
-     * `resilient_err` exactly as they always have.
-     *
-     * The deadline cell is keyed the same way (#238). A knob's deadline Sub
-     * carries its name, so a knob built as `name: "jev"` dispatches
-     * `jev_deadline` and mounts into a `jev_deadline` cell; an unnamed knob still
-     * dispatches and mounts `deadline_exceeded`. Before that, both mounts wrote
-     * the one unqualified `deadline_exceeded` key and the last spread silently
-     * dropped the other knob's deadline fold. The cell folds through
-     * {@link MountConfig.onDeadline}, since a call the timer settles emits no
-     * settle Msg and so reaches no `onErr`.
-     */
-    readonly update: Readonly<Record<AttemptType, MountedCell<Model, AttemptMsg, I, C>>> & {
-        readonly [K in ResilientOkType<N>]: MountedCell<Model, OkMsg, I, C>;
-    } & {
-        readonly [K in ResilientErrType<N>]: MountedCell<Model, ErrMsg, I, C>;
-    } & {
-        readonly [K in ResilientDeadlineType<N>]: MountedCell<Model, ResilientTimerMsg<N>, I, C>;
-    };
-    subscriptions(model: Model): readonly DeadlineSub<DeadlineNameOf<N>>[];
-    readonly subscribe: {
-        readonly deadline: typeof subscribeDeadline;
-    };
-    readonly interpret: Handlers;
-}
-/**
- * Pre-assemble a resilient-call knob into the fragments a machine definition
- * spreads, so mounting one is a spread instead of eight hand-spliced points.
- *
- * The three points that used to fail only at runtime are gone at the type
- * level rather than documented:
- *
- *   - The settle cells run the inherited `succeed` / `fail` verb and hand the
- *     already-settled Model to {@link SettleFold}. There is no cell for a
- *     consumer to write in the wrong order.
- *   - `interpret` is `knob.handlers()` — the form that RETURNS the settle Msg
- *     so it re-enters the reducer. A consumer that spreads the fragment cannot
- *     substitute a dispatching handler for it.
- *   - `subscribe` carries `subscribeDeadline`, so the retry timer is armed by
- *     construction rather than by remembering.
- *
- * A deadline-exceeded call settles inside the slice and emits no settle Msg, so
- * it reaches no `onErr`. {@link MountConfig.onDeadline} is that failure class's
- * fold — omit it and the slice still advances, exactly as omitting `onErr`
- * does.
- *
- * Nothing is taken away. The slice stays a plain field at `slice` that the
- * consumer reads, `replay` sees and the journal prints, and every verb the
- * fragments call is still exported and callable by hand — a consumer that
- * wants a settle cell this shape cannot express writes that one cell itself and
- * spreads the rest. PURE: a record of closures over `knob` and `config`, no
- * clock and no RNG.
- */
-declare function mountResilientCall<Slice extends string, I, R, Model extends {
-    readonly [K in Slice]: ResilientState<I, R>;
-}, AttemptType extends string, AttemptMsg, OkMsg extends {
-    readonly key: string;
-}, ErrMsg extends {
-    readonly key: string;
-}, Handlers, C extends Cmd = never, N extends string = DefaultResilientName>(knob: MountableKnob<I, R, OkMsg, ErrMsg, Handlers, N>, config: MountConfig<Model, Slice, I, R, AttemptType, AttemptMsg, OkMsg, ErrMsg, C, N>): MountedResilientCall<Model, Slice, I, R, AttemptType, AttemptMsg, OkMsg, ErrMsg, C, Handlers, N>;
 
-export { type SettleFold as A, type SlidingWindow as B, type CircuitConfig as C, type DeadlineConfig as D, canPass as E, type FailMsg as F, createResilientCall as G, defaultCircuitPolicy as H, initBucket as I, initCircuit as J, initWindow as K, liftResilience as L, type MountConfig as M, onFailure as N, onSuccess as O, record as P, refill as Q, type RunCmd as R, type SucceedMsg as S, type TokenBucket as T, remaining as U, runCmdDef as V, tryConsume as W, type ResilientState as a, type RateLimitConfig as b, type ResilientPorts as c, type ResilientHandlers as d, type ResilientConfig as e, type ResilientTimerMsg as f, type CacheConfig as g, type CallBudget as h, type CallPhase as i, type CircuitPolicy as j, type CircuitState as k, DEFAULT_RESILIENT_NAME as l, mountResilientCall as m, type DeadlineExceededError as n, type DeadlineNameOf as o, type DeadlineSettled as p, type DefaultResilientName as q, type MountableKnob as r, type MountedCell as s, type MountedResilientCall as t, type ResilientDeadlineType as u, type ResilientErrType as v, type ResilientOkType as w, type ResilientRunType as x, type RunCmdDef as y, type Settle as z };
+export { initBucket as A, initCircuit as B, type CacheConfig as C, DEFAULT_RESILIENT_NAME as D, initWindow as E, type FailMsg as F, liftResilience as G, onFailure as H, onSuccess as I, record as J, refill as K, remaining as L, runCmdDef as M, tryConsume as N, type RunCmd as R, type SucceedMsg as S, type TokenBucket as T, type ResilientState as a, type ResilientTimerMsg as b, type ResilientConfig as c, type CallBudget as d, type CallPhase as e, type CircuitConfig as f, type CircuitPolicy as g, type CircuitState as h, type DeadlineExceededError as i, type DeadlineNameOf as j, type DefaultResilientName as k, type RateLimitConfig as l, type DeadlineConfig as m, type ResilientDeadlineType as n, type ResilientErrType as o, type ResilientOkType as p, type ResilientRunType as q, type RunCmdDef as r, type RunErr as s, type SettleMsg as t, type SettleOutcome as u, type SettleResult as v, type SlidingWindow as w, canPass as x, createResilientCall as y, defaultCircuitPolicy as z };

package/dist/{index-DrIRb_Ch.d.ts → index-DU6JpQ8G.d.ts}

@@ -1,4 +1,4 @@
-import { B as BootingRuntime } from './runtime-types-CMF13BBh.js';
+import { B as BootingRuntime } from './runtime-types-CiVpC0HN.js';
 
 /**
  * A recorded run, sufficient to reproduce it via `../trace-replay`.