@demlik/tea 0.14.0 → 0.15.0

package/dist/{index-B5BZ-_cT.d.ts → index-CA_7I5g9.d.ts}

@@ -1,59 +1,6 @@
-import { a as CmdOf, b as CmdDef, i as CmdValue, C as Cmd } from './core-CTzMJ82M.js';
+import { a as CmdOf, b as CmdDef, i as NoCtx, C as Cmd } from './core-DnzqWy6u.js';
 import { RetryState, AnyRetryPolicy } from './retry-backoff/index.js';
-import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
-
-/**
- * The closed set of cross-module Msg/Cmd discriminant strings. Declared `as
- * const` so each entry is usable as both a value (construction / reducer keys /
- * switch labels) and, via `typeof MsgType.X`, a literal type (`readonly type:`
- * fields). The single source of truth for issue #60.
- */
-declare const MsgType: {
-    /** The "run the port for `key`" effect Cmd resilient-call emits. */
-    readonly ResilientRun: "resilient_run";
-    /** PRIVATE success settle Msg (read only by `agentEvents`, #47). */
-    readonly ResilientOk: "resilient_ok";
-    /** Failure settle Msg — routed to the `fail` verb (back off via retry). */
-    readonly ResilientErr: "resilient_err";
-    /** Begin a run. */
-    readonly AgentStart: "agent_start";
-    /** PRIVATE tool-fan-out success settle Msg (read only by `agentEvents`, #47). */
-    readonly AgentToolOk: "agent_tool_ok";
-    /** Tool-fan-out failure settle Msg. */
-    readonly AgentToolErr: "agent_tool_err";
-    /**
-     * Re-fire the one outstanding effect on rehydrate (the do↔agent seam). Fired
-     * by `do/host`'s `autoBoot` via the typed `agentBootMsg` constructor, matched
-     * by the agent reducer — see `AgentBootPort` in `../agent`.
-     */
-    readonly AgentBoot: "agent_boot";
-    /**
-     * Stop the run from outside and settle it `cancelled` — what an `AbortSignal`
-     * handed to `driveToDone` / a defined agent's `run` dispatches on abort. A
-     * transition, never a throw: the outcome lands in the Model, so a reload reads
-     * a run that ended rather than one to resume.
-     */
-    readonly AgentCancel: "agent_cancel";
-    /**
-     * The "summarize the oldest N turns" effect Cmd the agent emits when its
-     * `CompactionPolicy` asks to compact before a brain call. A DEDICATED
-     * round-trip (design B1), distinct from the brain call's `resilient_run`, so
-     * compaction is its own honest `Awaiting` state — see `../agent`.
-     */
-    readonly CompactRun: "compact_run";
-    /** Compaction round-trip resolved — carries the summary text the fold-back folds. */
-    readonly CompactOk: "compact_ok";
-    /** Compaction round-trip failed (exhausted retry) — surfaced as data, not a stall. */
-    readonly CompactErr: "compact_err";
-    /** Refresh port resolved — carries the fresh `Token`. */
-    readonly TokenRefreshed: "token_refreshed";
-    /** Refresh port rejected — carries the rejection (errors are data). */
-    readonly TokenRefreshFailed: "token_refresh_failed";
-    /** The 401 the consumer dispatches when a guarded call comes back unauthorized. */
-    readonly Unauthorized: "unauthorized";
-};
-/** The union of every discriminant string in the protocol. */
-type MsgTypeValue = (typeof MsgType)[keyof typeof MsgType];
+import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub, s as subscribeDeadline } from './index-HSYgG2Yt.js';
 
 /**
  * @packageDocumentation
@@ -404,13 +351,46 @@ interface DeadlineConfig {
     /** Budget of in-process time from the moment a call starts, in ms. */
     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.
+ */
+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 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
  * stays uniform across configs, but the gate is never consulted). An empty
  * config `{}` is a valid pass-through — a bare effect with no resilience at all.
+ *
+ * `N` is the knob's Msg-name family (see {@link ResilientName}); it is carried on
+ * the config so the run Cmd and the two settle Msgs are named from ONE place.
  */
-interface ResilientConfig {
+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.
+     *
+     * 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
+     * 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.
+     *
+     * The name is a value AND a type: the settle Msg types are generic in `N`, and
+     * `N` is not inferable from `I` / `R`, so an opted-in knob spells all three
+     * type arguments — `createResilientCall<In, Out, "jev">({ name: "jev", … })`.
+     * The `name` field is typed at `N`, so the two cannot drift apart.
+     */
+    readonly name?: N;
     /**
      * The backoff brick. Omit and a failure is terminal (no backoff, no timer).
      *
@@ -523,7 +503,7 @@ interface ResilientState<I, R> {
  * consumer's `handlers(ports)` interprets it; it carries no closure — `input`
  * is plain data (invariant 3).
  */
-declare function runCmdDef<I, R>(): CmdDef<"resilient_run", {
+declare function runCmdDef<I, R, N extends string = DefaultResilientName>(name?: N): CmdDef<`${N}_run`, {
     readonly key: string;
     readonly input: I;
 }, R, {
@@ -533,23 +513,48 @@ declare function runCmdDef<I, R>(): CmdDef<"resilient_run", {
     readonly [detail: string]: unknown;
     readonly _tag: "port_rejected";
 }, unknown>;
-type RunCmdDef<I, R> = ReturnType<typeof runCmdDef<I, R>>;
-type RunCmd<I> = CmdOf<RunCmdDef<I, unknown>>;
-/** Settle Msgs the `handlers` port dispatches back. `at` is stamped at the boundary. */
-type SucceedMsg<R> = {
-    readonly type: typeof MsgType.ResilientOk;
+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.
+ */
+type SucceedMsg<R, N extends string = DefaultResilientName> = {
+    readonly type: ResilientOkType<N>;
     readonly key: string;
     readonly result: R;
     readonly at: number;
 };
-type FailMsg = {
-    readonly type: typeof MsgType.ResilientErr;
+type FailMsg<N extends string = DefaultResilientName> = {
+    readonly type: ResilientErrType<N>;
     readonly key: string;
     readonly error: unknown;
     readonly at: number;
 };
-/** The retry / deadline timer Msg — `DeadlineExceeded`, keyed by the call `key`. */
-type ResilientTimerMsg = DeadlineExceeded;
+/**
+ * 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.
+ */
+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
+ * 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.
+ */
+type DeadlineNameOf<N extends string = DefaultResilientName> = N extends DefaultResilientName ? undefined : N;
+/**
+ * The retry / deadline timer Msg — a `DeadlineExceeded` whose tag is this
+ * knob's ({@link ResilientDeadlineType}), keyed by the call `key` through the
+ * Sub `id`. Bare `ResilientTimerMsg` is the default family's, so it is the same
+ * `DeadlineExceeded` it has always been.
+ */
+type ResilientTimerMsg<N extends string = DefaultResilientName> = DeadlineExceeded<DeadlineNameOf<N>>;
 /**
  * The plain-data error a deadline-failed call settles with. A `{_tag, ...}`
  * sentinel — NEVER a `new Error(...)` — so the slice stays JSON-serializable
@@ -562,6 +567,15 @@ 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`. */
@@ -579,27 +593,17 @@ interface ResilientPorts<I, R> {
  * `withResilience` (`../with-resilience`) — see the migration map at the top
  * of this module.
  */
-declare function createResilientCall<I, R>(config: ResilientConfig, rng?: () => number): {
+declare function createResilientCall<I, R, N extends string = DefaultResilientName>(config: ResilientConfig<N>, rng?: () => number): {
+    name: N;
     init: () => ResilientState<I, R>;
-    attempt: (s: ResilientState<I, R>, key: string, input: I, at: number) => readonly [ResilientState<I, R>, readonly RunCmd<I>[]];
+    attempt: (s: ResilientState<I, R>, key: string, input: I, at: number) => readonly [ResilientState<I, R>, readonly RunCmd<I, N>[]];
     resume: (s: ResilientState<I, R>, at: number) => ResilientState<I, R>;
-    succeed: (s: ResilientState<I, R>, key: string, msg: SucceedMsg<R>) => readonly [ResilientState<I, R>, readonly RunCmd<I>[]];
-    fail: (s: ResilientState<I, R>, key: string, msg: FailMsg) => readonly [ResilientState<I, R>, readonly RunCmd<I>[]];
-    settleFailed: (s: ResilientState<I, R>, key: string, error: unknown) => readonly [ResilientState<I, R>, readonly RunCmd<I>[]];
-    onTimer: (s: ResilientState<I, R>, msg: ResilientTimerMsg) => readonly [ResilientState<I, R>, readonly RunCmd<I>[]];
-    subs: (s: ResilientState<I, R>) => readonly DeadlineSub[];
-    handlers: (ports: ResilientPorts<I, R>) => {
-        resilient_run: (cmd: CmdValue<"resilient_run", {
-            readonly key: string;
-            readonly input: I;
-        }, {
-            readonly [detail: string]: unknown;
-            readonly _tag: "deadline_exceeded";
-        } | {
-            readonly [detail: string]: unknown;
-            readonly _tag: "port_rejected";
-        }, unknown>, ctx: Readonly<Record<never, never>>) => Promise<FailMsg | SucceedMsg<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>;
 };
 /**
  * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the
@@ -608,9 +612,195 @@ declare function createResilientCall<I, R>(config: ResilientConfig, rng?: () =>
  * 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.
+ *
+ * The record rebuild itself is `liftSlice` from the root door (#231) — this
+ * stays as the named, pre-keyed convenience for the `state.resilience` field,
+ * unchanged in name, signature and subpath.
  */
 declare function liftResilience<S extends {
     resilience: ResilientState<I, R>;
-}, I, R, C extends Cmd>(state: S, [slice, cmds]: readonly [ResilientState<I, R>, readonly C[]]): readonly [S, readonly C[]];
+}, 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 { runCmdDef as A, tryConsume as B, type CircuitConfig as C, type DeadlineConfig as D, type FailMsg as F, MsgType as M, type RunCmd as R, type SucceedMsg as S, type TokenBucket as T, type ResilientState as a, type MsgTypeValue as b, type RateLimitConfig as c, type ResilientPorts 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, type DeadlineExceededError as l, type RunCmdDef as m, type SlidingWindow as n, canPass as o, createResilientCall as p, defaultCircuitPolicy as q, initBucket as r, initCircuit as s, initWindow as t, liftResilience as u, onFailure as v, onSuccess as w, record as x, refill as y, remaining as z };
+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 };

package/dist/{index-DJWIER_3.d.ts → index-CSyMYDAB.d.ts}

@@ -1,4 +1,4 @@
-import { S as Store } from './runtime-types-LWDoi943.js';
+import { S as Store } from './runtime-types-CMF13BBh.js';
 
 /**
  * internal/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.

package/dist/{index-6A7dB8f6.d.ts → index-CuNO9m8i.d.ts}

@@ -1,5 +1,5 @@
-import { C as Cmd, P as Port } from './core-CTzMJ82M.js';
-import { Q as QueueItem } from './index-DJWIER_3.js';
+import { C as Cmd, P as Port } from './core-DnzqWy6u.js';
+import { Q as QueueItem } from './index-CSyMYDAB.js';
 
 /**
  * internal/flow/fan-out — scatter-gather over a bounded-concurrency work list.

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

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

package/dist/{index-q0hXFeZ0.d.ts → index-HSYgG2Yt.d.ts}

@@ -1,5 +1,5 @@
-import { S as Sub, c as SubId } from './core-CTzMJ82M.js';
-import { S as SubscribeHandler } from './types-DP3f5NIl.js';
+import { S as Sub, c as SubId } from './core-DnzqWy6u.js';
+import { S as SubscribeHandler } from './types-BseNPIhr.js';
 
 /**
  * internal/resilience/cache — a TTL cache as pure state, PLUS a periodic eviction Sub.
@@ -208,9 +208,9 @@ declare const cacheEvictionSubscribe: SubscribeHandler<CacheEvictionSub, CacheEv
  * noun that doubles as the SubId family); same shape family as the
  * `TimeoutSubData` the `fromTimeout` factory consumes.
  */
-type DeadlineSub = Sub<"deadline"> & {
+type DeadlineSub<N extends string | undefined = undefined> = Sub<"deadline"> & {
     readonly atMs: number;
-} & DeadlineOpts;
+} & DeadlineOpts<N>;
 /**
  * Additive options the `deadlineSub` factory folds onto the Sub literal. This
  * is the extension seam (invariant 5 — composition by reduction): future fields
@@ -221,10 +221,24 @@ type DeadlineSub = Sub<"deadline"> & {
  * they ask for what they need by name, never positionally, so a shape extension
  * never rewrites the ~13 `deadlineSub(id, atMs)` call sites.
  *
- * Empty today on purpose — the seam exists before the first extension does, so
- * the first field is a one-line additive change, not a 13-site migration.
+ * The first field to land here is {@link DeadlineOpts.name} — the knob name the
+ * dispatched Msg tag is derived from — and it landed exactly that way: one
+ * optional member, zero rewritten call sites.
  */
-type DeadlineOpts = {};
+type DeadlineOpts<N extends string | undefined = undefined> = {
+    /**
+     * The knob this deadline belongs to. Present → the dispatched Msg's tag is
+     * `` `${name}_deadline` ``; absent → the tag stays the bare
+     * `"deadline_exceeded"` every machine wired before this field is already
+     * handling. `N` is the name as a TYPE as well as a value, so a consumer's
+     * cell key and the Msg type are derived from one place and cannot drift.
+     *
+     * Name a deadline when a machine arms more than one family of them. The Sub
+     * *id* was already scoped (`` `${name}:deadline:${key}` ``); this scopes the
+     * Msg the Sub dispatches, which is what a reducer cell keys off.
+     */
+    readonly name?: N;
+};
 /**
  * The Msg the deadline dispatches when the wall clock crosses `atMs`. Exported
  * as a tagged shape so consumers can union it into their machine's Msg type and
@@ -238,11 +252,19 @@ type DeadlineOpts = {};
  * they prefer — `deadlineExceeded(...)` only fixes the wire shape, not the
  * consumer's local dialect.
  */
-type DeadlineExceeded = {
-    readonly type: "deadline_exceeded";
+type DeadlineExceeded<N extends string | undefined = undefined> = {
+    readonly type: DeadlineMsgType<N>;
     readonly id: string;
     readonly atMs: number;
 };
+/**
+ * The dispatched Msg's tag, derived from the deadline's optional name. A named
+ * deadline speaks `` `${N}_deadline` ``; an unnamed one speaks the bare
+ * `"deadline_exceeded"` literal, which is what `DeadlineExceeded` with no type
+ * argument still means — so every machine wired before the name existed keeps
+ * the exact type it had.
+ */
+type DeadlineMsgType<N extends string | undefined> = N extends string ? `${N}_deadline` : "deadline_exceeded";
 /**
  * Build a deadline Sub literal. Pure data — no clock read, no timer; the timer
  * is armed later by the `subscribe` cell. `id` is branded via `subId(...)` so
@@ -265,7 +287,7 @@ type DeadlineExceeded = {
  *             optionality is the future-proofing seam — extending the shape
  *             never breaks an existing `deadlineSub(id, atMs)` call site.
  */
-declare function deadlineSub(id: string, atMs: number, opts?: DeadlineOpts): DeadlineSub;
+declare function deadlineSub<N extends string | undefined = undefined>(id: string, atMs: number, opts?: DeadlineOpts<N>): DeadlineSub<N>;
 /**
  * The host-plugged timer backing. Given the deadline's stable `id`, its
  * absolute `atMs`, and the Msg to fire, arm the platform-appropriate timer
@@ -303,7 +325,7 @@ type ArmTimer<M> = (id: SubId, atMs: number, msg: M, dispatch: (msg: M) => void)
  * `subscribeWith(setTimeoutArmTimer())`, so there is one deadline surface and
  * one anchor, not a second one per host.
  */
-declare function subscribeWith(armTimer: ArmTimer<DeadlineExceeded>): SubscribeHandler<DeadlineSub, DeadlineExceeded, unknown>;
+declare function subscribeWith<N extends string | undefined = undefined>(armTimer: ArmTimer<DeadlineExceeded<N>>): SubscribeHandler<DeadlineSub<N>, DeadlineExceeded<N>, unknown>;
 /**
  * The `setTimeout` timer backing — for node / browser / any host whose timer is
  * a plain `setTimeout`. Arms for the REMAINING time (`max(0, atMs - Date.now())`,
@@ -317,7 +339,7 @@ declare function subscribeWith(armTimer: ArmTimer<DeadlineExceeded>): SubscribeH
  * it plugs its own `armTimer` (a `do_alarm` registration) into
  * {@link subscribeWith}.
  */
-declare function setTimeoutArmTimer(): ArmTimer<DeadlineExceeded>;
+declare function setTimeoutArmTimer<N extends string | undefined = undefined>(): ArmTimer<DeadlineExceeded<N>>;
 /**
  * The `subscribe["deadline"]` handler for the DEFAULT `setTimeout` backing. Arms a
  * one-shot timer for the remaining delay `max(0, atMs - Date.now())` and
@@ -333,13 +355,26 @@ declare function setTimeoutArmTimer(): ArmTimer<DeadlineExceeded>;
  *   subscribe: {
  *     deadline: subscribeDeadline,
  *   }
+ *
+ * Generic in the deadline's name so ONE handler serves every knob in a machine:
+ * the tag it dispatches is read off the Sub's own `name`, so a machine mounting
+ * a named knob beside an unnamed one wires this same cell once and each Sub
+ * still dispatches its own tag.
  */
-declare const subscribeDeadline: SubscribeHandler<DeadlineSub, DeadlineExceeded, unknown>;
+declare const subscribeDeadline: <N extends string | undefined = undefined>(sub: DeadlineSub<N>, ctx: unknown, dispatch: (msg: DeadlineExceeded<N>) => void) => () => void;
 /**
  * Construct the Msg the deadline dispatches. Exported so consumers can build /
  * assert the same shape (and so the subscribe cell and tests share one
  * constructor rather than two literals that can drift).
  */
-declare function deadlineExceeded(id: string, atMs: number): DeadlineExceeded;
+declare function deadlineExceeded<N extends string | undefined = undefined>(id: string, atMs: number, name?: N): DeadlineExceeded<N>;
+/**
+ * The one place the named tag is spelled. `undefined` → the bare
+ * `"deadline_exceeded"` literal; a name → `` `${name}_deadline` ``. Exported so
+ * a consumer keying a reducer cell off a named deadline derives the key from
+ * the same function the Sub dispatches through, instead of re-spelling the
+ * template and drifting.
+ */
+declare function deadlineMsgType<N extends string | undefined>(name?: N): DeadlineMsgType<N>;
 
-export { type ArmTimer as A, type CacheEvictionSub as C, type DeadlineExceeded as D, type TtlCache as T, type DeadlineSub as a, deadlineSub as b, type CacheEvictMsg as c, deadlineExceeded as d, type CacheEntry as e, type DeadlineOpts as f, cacheEvictMsg as g, cacheEvictionSub as h, cacheEvictionSubscribe as i, evictExpired as j, get as k, has as l, initCache as m, set as n, setTimeoutArmTimer as o, subscribeWith as p, remove as r, subscribeDeadline as s };
+export { type ArmTimer as A, type CacheEvictionSub as C, type DeadlineExceeded as D, type TtlCache as T, type DeadlineSub as a, deadlineSub as b, type CacheEvictMsg as c, deadlineExceeded as d, type CacheEntry as e, type DeadlineMsgType as f, type DeadlineOpts as g, cacheEvictMsg as h, cacheEvictionSub as i, cacheEvictionSubscribe as j, deadlineMsgType as k, evictExpired as l, get as m, has as n, initCache as o, set as p, setTimeoutArmTimer as q, remove as r, subscribeDeadline as s, subscribeWith as t };

package/dist/{index-NjrT3fL2.d.ts → index-KXqTRJyb.d.ts}

@@ -1,7 +1,7 @@
-import { I as Interpret, C as Cmd } from './core-CTzMJ82M.js';
-import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotStore, c as SnapshotSavedMsg, d as SnapshotFailedMsg, e as SnapshotLoadedMsg, f as SnapshotLoadFailedMsg, g as SnapshotLoadCmd } from './index-DMCeMPMJ.js';
-import { D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
-import { Q as QueueItem } from './index-DJWIER_3.js';
+import { I as Interpret, C as Cmd } from './core-DnzqWy6u.js';
+import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotStore, c as SnapshotSavedMsg, d as SnapshotFailedMsg, e as SnapshotLoadedMsg, f as SnapshotLoadFailedMsg, g as SnapshotLoadCmd } from './index-ZCMhnVKN.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-HSYgG2Yt.js';
+import { Q as QueueItem } from './index-CSyMYDAB.js';
 
 /**
  * internal/flow/monitored-run — a long-running operation that is BOTH staged and

package/dist/{index-DMCeMPMJ.d.ts → index-ZCMhnVKN.d.ts}

@@ -1,4 +1,4 @@
-import { a as CmdOf, b as CmdDef, C as Cmd, I as Interpret } from './core-CTzMJ82M.js';
+import { a as CmdOf, b as CmdDef, C as Cmd, I as Interpret } from './core-DnzqWy6u.js';
 
 /**
  * The snapshot knob.