@demlik/tea 0.18.0 → 0.20.0

package/dist/idempotency/index.d.ts

@@ -1,9 +1,9 @@
 import { I as IdempotencyStore } from '../index-Bc40JWVl.js';
 export { a as IdempotencyEntry, e as evictExpired, i as initStore, r as recall, b as remember, s as seen } from '../index-Bc40JWVl.js';
-import { a as CmdOf, b as CmdDef } from '../core-Ce9ncpuv.js';
-import { Q as QueueItem } from '../index-DWdg7R1l.js';
+import { a as CmdOf, b as CmdDef } from '../core-CtvAyPpH.js';
+import { Q as QueueItem } from '../index-D3NY3VCN.js';
 import '@standard-schema/spec';
-import '../runtime-types-BKg2CGMx.js';
+import '../runtime-types-DEluQgGO.js';
 
 /**
  * A cached intake entry: either a key whose work is still in flight
@@ -69,6 +69,10 @@ declare function intakeProcessDef<P>(): CmdDef<"intake:process", {
     /** The original payload, for the worker to process. */
     readonly payload: P;
 }, undefined, never>;
+/**
+ * The Cmd intake emits for a first-time request: process `payload` for the
+ * queue item `itemId`.
+ */
 type IntakeProcessCmd<P> = CmdOf<ReturnType<typeof intakeProcessDef<P>>>;
 /**
  * A duplicate of an already-completed key arrived — replay the cached result
@@ -80,6 +84,10 @@ declare function intakeReplayDef<R>(): CmdDef<"intake:replay", {
     /** The result the ORIGINAL request produced, recalled from the cache. */
     readonly result: R;
 }, undefined, never>;
+/**
+ * The Cmd intake emits for a duplicate of a completed request: hand back the
+ * cached `result` instead of redoing the work.
+ */
 type IntakeReplayCmd<R> = CmdOf<ReturnType<typeof intakeReplayDef<R>>>;
 /** The Cmd union the intake verbs emit. */
 type IntakeCmd<P, R> = IntakeProcessCmd<P> | IntakeReplayCmd<R>;

package/dist/idempotency/index.js

@@ -1,8 +1,8 @@
-export { createIntake, intakeProcessDef, intakeReplayDef } from '../chunk-JYNYG5SF.js';
+export { createIntake, intakeProcessDef, intakeReplayDef } from '../chunk-NGYFBD5G.js';
 export { evictExpired, initStore, recall, remember, seen } from '../chunk-PR6TB3BL.js';
 import '../chunk-4LPY67E4.js';
 import '../chunk-TXN2KFHF.js';
-import '../chunk-FNGZMVIT.js';
-import '../chunk-AIIXV4XB.js';
+import '../chunk-DVNXEB7V.js';
+import '../chunk-RKVUVALV.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{index-D8sYVzCI.d.ts → index-Bk2hBUdK.d.ts}

@@ -1,4 +1,4 @@
-import { a as CmdOf, b as CmdDef, d as SettledOk, e as SettledErr, f as TaggedError, C as Cmd } from './core-Ce9ncpuv.js';
+import { a as CmdOf, b as CmdDef, d as SettledOk, e as SettledErr, f as TaggedError, C as Cmd } from './core-CtvAyPpH.js';
 
 /**
  * The snapshot knob.
@@ -79,6 +79,10 @@ declare function snapshotWriteDef<V>(): CmdDef<"snapshot_write", {
     readonly [detail: string]: unknown;
     readonly _tag: "snapshot_write_failed";
 }>;
+/**
+ * The Cmd a snapshot decision emits to write a checkpoint: `payload` under
+ * `key`, at sequence `seq`.
+ */
 type SnapshotWriteCmd<V> = CmdOf<ReturnType<typeof snapshotWriteDef<V>>>;
 /**
  * The checkpoint-READ Cmd a `requestLoad` decision emits — the recovery half of
@@ -98,6 +102,7 @@ declare function snapshotLoadDef<V>(): CmdDef<"snapshot_load", {
     readonly [detail: string]: unknown;
     readonly _tag: "snapshot_load_failed";
 }>;
+/** The Cmd `requestLoad` emits to read the checkpoint saved under `key`. */
 type SnapshotLoadCmd<V = unknown> = CmdOf<ReturnType<typeof snapshotLoadDef<V>>>;
 /**
  * The Msg the engine mints when a write lands. Fold it through

package/dist/{index-2kNxy6az.d.ts → index-CKtEKGyp.d.ts}

@@ -1,6 +1,6 @@
-import { a as CmdOf, b as CmdDef, f as TaggedError, n as MalformedResult, T as TimerDeps, C as Cmd } from './core-Ce9ncpuv.js';
+import { a as CmdOf, b as CmdDef, f as TaggedError, n as MalformedResult, T as TimerDeps, C as Cmd } from './core-CtvAyPpH.js';
 import { RetryState, AnyRetryPolicy } from './retry-backoff/index.js';
-import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-e36uEyl4.js';
+import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-CVU7SK3a.js';
 
 /**
  * @packageDocumentation
@@ -357,6 +357,10 @@ interface DeadlineConfig {
  * stay the vocabulary of every knob that passes no name.
  */
 declare const DEFAULT_RESILIENT_NAME = "resilient";
+/**
+ * The Msg-name family a resilient call uses when it is given no name:
+ * `resilient`.
+ */
 type DefaultResilientName = typeof DEFAULT_RESILIENT_NAME;
 /** The run Cmd's `type` for the `N` family. */
 type ResilientRunType<N extends string> = `${N}_run`;
@@ -531,6 +535,10 @@ declare function runCmdDef<I, R, N extends string = DefaultResilientName>(name?:
     readonly [detail: string]: unknown;
     readonly _tag: "port_rejected";
 }>;
+/**
+ * The type of the `Cmd.define` definition that `runCmdDef` returns for a
+ * resilient call's run Cmd.
+ */
 type RunCmdDef<I, R, N extends string = DefaultResilientName> = ReturnType<typeof runCmdDef<I, R, N>>;
 /**
  * The run Cmd value. `R` is its settle value — `unknown` reads any knob's run
@@ -556,6 +564,10 @@ type SucceedMsg<R, N extends string = DefaultResilientName, I = unknown> = {
     readonly value: R;
     readonly at: number;
 };
+/**
+ * The Msg the engine mints when a resilient call's handler fails:
+ * `<name>_run_err`, carrying the Cmd and the error.
+ */
 type FailMsg<N extends string = DefaultResilientName, I = unknown, E = RunErr | MalformedResult> = {
     readonly type: ResilientErrType<N>;
     readonly cmd: RunCmd<I, N>;
@@ -694,4 +706,4 @@ 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[]];
 
-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 };
+export { initBucket as A, initCircuit as B, type CacheConfig as C, type DefaultResilientName 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 ResilientTimerMsg as a, type ResilientState as b, type DeadlineNameOf as c, type ResilientConfig as d, type CallBudget as e, type CallPhase as f, type CircuitConfig as g, type CircuitPolicy as h, type CircuitState as i, DEFAULT_RESILIENT_NAME as j, type DeadlineExceededError 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-e36uEyl4.d.ts → index-CVU7SK3a.d.ts}

@@ -1,5 +1,5 @@
-import { k as SubId, c as Sub, l as DepKeyedSub, D as Dispose, T as TimerDeps } from './core-Ce9ncpuv.js';
-import { S as SubscribeHandler } from './types-SzNSHKlV.js';
+import { k as SubId, S as Sub, l as DepKeyedSub, D as Dispose, T as TimerDeps } from './core-CtvAyPpH.js';
+import { S as SubscribeHandler } from './types-CXNzlbAg.js';
 
 /**
  * internal/resilience/deadline — a one-shot Sub that fires when an ABSOLUTE wall-clock

package/dist/{index-Dy3379ve.d.ts → index-CZZ3HI-Z.d.ts}

@@ -1,7 +1,7 @@
-import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-Ce9ncpuv.js';
-import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-D8sYVzCI.js';
-import { D as DeadlineExceeded, a as DeadlineSub } from './index-e36uEyl4.js';
-import { Q as QueueItem } from './index-DWdg7R1l.js';
+import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-CtvAyPpH.js';
+import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-Bk2hBUdK.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-CVU7SK3a.js';
+import { Q as QueueItem } from './index-D3NY3VCN.js';
 
 /**
  * The monitored-run knob. EVERY field is optional:

package/dist/{index-Ce5GYAuI.d.ts → index-CrcoVfd_.d.ts}

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

package/dist/{index-DWdg7R1l.d.ts → index-D3NY3VCN.d.ts}

@@ -1,4 +1,4 @@
-import { S as Store } from './runtime-types-BKg2CGMx.js';
+import { S as Store } from './runtime-types-DEluQgGO.js';
 
 /**
  * internal/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.
@@ -20,6 +20,10 @@ import { S as Store } from './runtime-types-BKg2CGMx.js';
  * their own store and put the foreign-key string in `output`.
  */
 
+/**
+ * Where a queue item is in its lifecycle: `pending`, `running`, `done`,
+ * `failed` or `cancelled`.
+ */
 type QueueItemStatus = "pending" | "running" | "done" | "failed" | "cancelled";
 /**
  * A single queue entry. Every field is `readonly`: a persisted slice is

package/dist/{index-B1Wzarkl.d.ts → index-Dl71V7kt.d.ts}

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

package/dist/{index-Bf9_bNql.d.ts → index-EIgfl83J.d.ts}

@@ -1,5 +1,5 @@
-import { C as Cmd, T as TimerDeps, S as Subscribe } from './core-Ce9ncpuv.js';
-import { D as DeadlineExceeded, a as DeadlineSub, b as DeadlinesSub } from './index-e36uEyl4.js';
+import { C as Cmd, T as TimerDeps, c as Subscribe } from './core-CtvAyPpH.js';
+import { D as DeadlineExceeded, a as DeadlineSub, b as DeadlinesSub } from './index-CVU7SK3a.js';
 
 /**
  * internal/flow/batch-window — coalesce a stream of items into size- or

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { B as BootingRuntime, R as Runtime } from './runtime-types-BKg2CGMx.js';
-export { b as BootedRunHandle, d as Branded, C as CtxArg, D as DeletableStore, e as DispatchDiscardedError, f as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, E as EngineRun, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, l as MachineTypes, M as Migrated, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, m as Refusal, c as RunHandle, n as RunOptions, o as RuntimeDiscardNotice, p as RuntimeDiscardedError, q as RuntimeErrorContext, r as RuntimeErrorPhase, s as RuntimeRef, t as Schema, S as Store, u as StoreConflictError, v as StoreRefusedError, a as Supervision, w as SupervisionStrategy, x as TelemetryEvent, T as TelemetrySink, _ as __resetPortRegistry, y as absurd, z as asReducer, A as defineMachine, G as definePort, H as isFencedStore, J as noop, K as refuse, L as replay, N as schemaMigrate, U as tryApplyCell, V as tryFoldMsgs, W as tryInterpret, X as wrapDetached } from './runtime-types-BKg2CGMx.js';
-import { C as Cmd, c as Sub, M as Machine, P as Port, l as DepKeyedSub, D as Dispose } from './core-Ce9ncpuv.js';
-export { A as AnyCmdDef, r as AsyncSchemaError, B as BuiltinSub, s as BuiltinSubType, b as CmdDef, t as CmdInput, a as CmdOf, q as CmdValue, u as DeclaredErrorsOf, E as ErrOf, v as ErrorsOf, w as ExhaustiveTransitions, x as Identity, I as Interpret, y as InterpretArg, z as InterpretCell, j as InterpretDetached, F as MachineShape, n as MalformedResult, N as NoCellError, G as NoCtx, p as OkOf, J as OkOfCmd, O as Outcome, K as OutcomeContractError, L as OutcomeHelpers, Q as PortEmitter, g as Reducer, R as RunHandlers, h as Settled, e as SettledErr, d as SettledOk, k as SubId, S as Subscribe, V as SubscribeArg, X as SyncReturn, o as Tagged, f as TaggedError, T as TimerDeps, m as TimerSub, i as Transitions, Y as UndeclaredFailureError, U as UpdateForm, W as Wired, Z as acceptedTypes, _ as acceptsOf, $ as applyCell, a0 as applyCellChecked, a1 as describeMachine, a2 as detectUpdateForm, a3 as foldMsgs, a4 as foldUpdates, a5 as formOf, a6 as msgKeysOf, a7 as structuralHash, a8 as subId, a9 as subIdOf } from './core-Ce9ncpuv.js';
-import { S as SubscribeHandler } from './types-SzNSHKlV.js';
+import { B as BootingRuntime, R as Runtime } from './runtime-types-DEluQgGO.js';
+export { b as BootedRunHandle, e as Branded, C as CtxArg, D as DeletableStore, f as DispatchDiscardedError, c as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, E as EngineRun, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, l as MachineTypes, M as Migrated, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, m as Refusal, d as RunHandle, n as RunOptions, o as RuntimeDiscardNotice, p as RuntimeDiscardedError, q as RuntimeErrorContext, r as RuntimeErrorPhase, s as RuntimeRef, t as Schema, S as Store, u as StoreConflictError, v as StoreRefusedError, a as Supervision, w as SupervisionStrategy, x as TelemetryEvent, T as TelemetrySink, _ as __resetPortRegistry, y as absurd, z as asReducer, A as defineMachine, G as definePort, H as isFencedStore, J as noop, K as refuse, L as replay, N as schemaMigrate, U as tryApplyCell, V as tryFoldMsgs, W as tryInterpret, X as wrapDetached } from './runtime-types-DEluQgGO.js';
+import { C as Cmd, S as Sub, M as Machine, P as Port, l as DepKeyedSub, D as Dispose } from './core-CtvAyPpH.js';
+export { A as AnyCmdDef, v as AsyncSchemaError, B as BuiltinSub, q as BuiltinSubType, b as CmdDef, w as CmdInput, a as CmdOf, u as CmdValue, p as DeclaredErrorsOf, t as ErrOf, E as ErrorsOf, x as ExhaustiveTransitions, y as Identity, I as Interpret, z as InterpretArg, F as InterpretCell, j as InterpretDetached, G as MachineShape, n as MalformedResult, N as NoCellError, J as NoCtx, s as OkOf, o as OkOfCmd, O as Outcome, K as OutcomeContractError, L as OutcomeHelpers, Q as PortEmitter, g as Reducer, R as RunHandlers, h as Settled, e as SettledErr, d as SettledOk, k as SubId, c as Subscribe, V as SubscribeArg, X as SyncReturn, r as Tagged, f as TaggedError, T as TimerDeps, m as TimerSub, i as Transitions, Y as UndeclaredFailureError, U as UpdateForm, W as Wired, Z as acceptedTypes, _ as acceptsOf, $ as applyCell, a0 as applyCellChecked, a1 as describeMachine, a2 as detectUpdateForm, a3 as foldMsgs, a4 as foldUpdates, a5 as formOf, a6 as msgKeysOf, a7 as structuralHash, a8 as subId, a9 as subIdOf } from './core-CtvAyPpH.js';
+import { S as SubscribeHandler } from './types-CXNzlbAg.js';
 import '@standard-schema/spec';
 
 /**
@@ -69,6 +69,10 @@ interface ReadStep<In, Out> {
  */
 declare function readInOrder<In, Out>(input: In, order: readonly ReadStep<In, Out>[], absent: Out): Out;
 
+/**
+ * A bounded log of a runtime's recent `(msg, state)` transitions, returned by
+ * `historyTracker`. Use it to feed a debug inspector.
+ */
 interface HistoryTracker<S, M extends {
     type: string;
 }> {
@@ -317,44 +321,84 @@ interface MinimalWebSocket {
 type BroadcastSubData = {
     readonly channelName: string;
 };
+/**
+ * Build a Sub runner that listens on the `BroadcastChannel` named by
+ * `sub.deps.channelName` and dispatches `msgFn(event, sub)` for each message.
+ * Returning `null` from `msgFn` drops the event.
+ */
 declare function fromBroadcastChannel<S extends Sub<string, BroadcastSubData>, M>(msgFn: (event: MinimalMessageEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
 
 type EventSourceSubData = {
     readonly url: string;
 };
+/**
+ * Options for `fromEventSource`: map each server-sent message, error and open
+ * event to a Msg, or to `null` to drop it.
+ */
 interface EventSourceFactoryOpts<S, M> {
     onMessage: (data: string, sub: S) => M | null;
     onError?: (event: MinimalEvent, sub: S) => M | null;
     onOpen?: (sub: S) => M | null;
 }
+/**
+ * Build a Sub runner that opens an `EventSource` on `sub.deps.url` and
+ * dispatches a Msg for each server-sent event.
+ */
 declare function fromEventSource<S extends Sub<string, EventSourceSubData>, M>(opts: EventSourceFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
+/**
+ * Build a Sub runner that listens for `eventName` on a DOM-style event target
+ * and dispatches `msgFn(event, sub)` for each event.
+ */
 declare function fromEventTarget<S extends Sub, M>(getTarget: () => MinimalEventTarget, eventName: string, msgFn: (event: MinimalEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
 
 type IntervalSubData = {
     readonly intervalMs: number;
 };
+/**
+ * Build a Sub runner that dispatches `msgFn(sub)` every `sub.deps.intervalMs`
+ * milliseconds while the Sub is on.
+ */
 declare function fromInterval<S extends Sub<string, IntervalSubData>, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
 
+/**
+ * Build a Sub runner that listens to a `Port` on another runtime and dispatches
+ * `msgFn(value, sub)` for each value emitted. Use it to let one machine react
+ * to another's announcements.
+ */
 declare function fromPort<S extends Sub, M, Ctx, T, RS = unknown, RM extends {
     type: string;
 } = {
     type: string;
 }>(selectRuntime: (ctx: Ctx) => Runtime<RS, RM>, port: Port<T>, msgFn: (value: T, sub: S) => M | null): SubscribeHandler<S, M, Ctx>;
 
+/** The `deps` a WebSocket Sub carries: the `wsUrl` to connect to. */
 type WebSocketSubData = {
     readonly wsUrl: string;
 };
+/**
+ * Options for `fromWebSocket`: map each message, open, error and close event to
+ * a Msg, or to `null` to drop it.
+ */
 interface WebSocketFactoryOpts<S, M> {
     onMessage: (data: unknown, sub: S) => M | null;
     onOpen?: (sub: S) => M | null;
     onError?: (event: MinimalEvent, sub: S) => M | null;
     onClose?: (code: number, reason: string, sub: S) => M | null;
 }
+/**
+ * Build a Sub runner that opens a WebSocket to `sub.deps.wsUrl` and dispatches
+ * a Msg for each socket event. It does not reconnect; use
+ * `fromReconnectingWebSocket` for that.
+ */
 declare function fromWebSocket<S extends Sub<string, WebSocketSubData>, M>(opts: WebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
 /** Cancels a scheduled reconnect timer (the inverse of `schedule`). */
 type CancelTimer = () => void;
+/**
+ * Options for `fromReconnectingWebSocket`: the event-to-Msg mappers, the
+ * backoff settings, and an injectable `connect` and `schedule` for tests.
+ */
 interface ReconnectingWebSocketFactoryOpts<S, M> {
     onMessage: (data: unknown, sub: S) => M | null;
     onOpen?: (sub: S) => M | null;
@@ -375,11 +419,19 @@ interface ReconnectingWebSocketFactoryOpts<S, M> {
     /** Inject the timer (defaults to `setTimeout`/`clearTimeout`); the test seam. */
     schedule?: (fn: () => void, ms: number) => CancelTimer;
 }
+/**
+ * Build a Sub runner that keeps a WebSocket to `sub.deps.wsUrl` open,
+ * reconnecting with backoff when it drops.
+ */
 declare function fromReconnectingWebSocket<S extends Sub<string, WebSocketSubData>, M>(opts: ReconnectingWebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
 type TimeoutSubData = {
     readonly delayMs: number;
 };
+/**
+ * Build a Sub runner that dispatches `msgFn(sub)` once, `sub.deps.delayMs`
+ * milliseconds after the Sub turns on. Turning the Sub off first cancels it.
+ */
 declare function fromTimeout<S extends Sub<string, TimeoutSubData>, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
 
 /**
@@ -387,6 +439,10 @@ declare function fromTimeout<S extends Sub<string, TimeoutSubData>, M>(msgFn: (s
  * key. The consumer's Sub union (`types.sub`) includes it directly.
  */
 type ManagedResourceSub<N extends string, TKey> = Sub<N, TKey>;
+/**
+ * Options for `defineManagedResource`: the resource's `name`, how to `acquire`
+ * it for a key, and how to `release` the handle.
+ */
 interface DefineManagedResourceOpts<N extends string, TKey, Handle, Ctx> {
     /**
      * A short, stable name — and the resource's Sub `type`. The machine's
@@ -551,6 +607,11 @@ type TransportFactory<K> = (key: K) => Transport;
  * consumer's Sub union (`types.sub`) includes it directly.
  */
 type TransportSub<N extends string, TKey> = Sub<N, TKey>;
+/**
+ * Options for `fromTransport`: the seam's `name`, how to open the transport,
+ * and how inbound values, outbound values and a dropped connection map to and
+ * from Msgs.
+ */
 interface FromTransportOpts<N extends string, TKey, Inbound, Outbound, M, Ctx> {
     /**
      * A short, stable name for this seam — and its Sub `type`. The machine's

package/dist/index.js

@@ -1,4 +1,4 @@
-export { NO_ACK, ack, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, liftSlice, nextSeq, partitionByAck, readInOrder, reconcile, tagSeq } from './chunk-FNGZMVIT.js';
-export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NoCellError, Outcome, OutcomeContractError, PortNameCollisionError, QuiescenceTimeoutError, Refusal, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, StoreRefusedError, UndeclaredFailureError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, applyCell, applyCellChecked, asReducer, defineMachine, definePort, describeMachine, detectUpdateForm, foldMsgs, foldUpdates, formOf, isFencedStore, msgKeysOf, noop, refuse, replay, schemaMigrate, structuralHash, subId, subIdOf, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached } from './chunk-AIIXV4XB.js';
+export { NO_ACK, ack, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, liftSlice, nextSeq, partitionByAck, readInOrder, reconcile, tagSeq } from './chunk-DVNXEB7V.js';
+export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NoCellError, Outcome, OutcomeContractError, PortNameCollisionError, QuiescenceTimeoutError, Refusal, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, StoreRefusedError, UndeclaredFailureError, __resetPortRegistry, absurd, acceptedTypes, acceptsOf, applyCell, applyCellChecked, asReducer, defineMachine, definePort, describeMachine, detectUpdateForm, foldMsgs, foldUpdates, formOf, isFencedStore, msgKeysOf, noop, refuse, replay, schemaMigrate, structuralHash, subId, subIdOf, tryApplyCell, tryFoldMsgs, tryInterpret, wrapDetached } from './chunk-RKVUVALV.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/jev/index.d.ts

@@ -1,13 +1,13 @@
-import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState, b as ResilientTimerMsg } from '../index-2kNxy6az.js';
-import { O as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, l as DepKeyedSub, m as TimerSub } from '../core-Ce9ncpuv.js';
+import { O as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, l as DepKeyedSub, m as TimerSub } from '../core-CtvAyPpH.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { D as DeadlineExceeded, a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-e36uEyl4.js';
-import { S as SubscribeHandler } from '../types-SzNSHKlV.js';
-import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-Bf9_bNql.js';
-import { F as FanOutState } from '../index-Ce5GYAuI.js';
+import { a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-CVU7SK3a.js';
+import { D as DefaultResilientName, R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientTimerMsg, b as ResilientState, c as DeadlineNameOf } from '../index-CKtEKGyp.js';
+import { S as SubscribeHandler } from '../types-CXNzlbAg.js';
+import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-EIgfl83J.js';
+import { F as FanOutState } from '../index-CrcoVfd_.js';
 import '@standard-schema/spec';
-import '../index-DWdg7R1l.js';
-import '../runtime-types-BKg2CGMx.js';
+import '../index-D3NY3VCN.js';
+import '../runtime-types-DEluQgGO.js';
 
 /**
  * @packageDocumentation
@@ -400,9 +400,17 @@ declare const DEFAULT_JEV_MODEL = "jev-latest";
  * sent on every request and the type that makes the answers narrow at the call
  * site, so it belongs to the knob rather than to a call.
  */
-interface JevAskConfig<Q extends JevQuestionMap> {
+interface JevAskConfig<Q extends JevQuestionMap, N extends string = DefaultResilientName> {
     /** The question map every request carries; its keys type the answers. */
     readonly questions: Q;
+    /**
+     * What this knob's Cmd and Msgs are called: `<name>_run`, `<name>_run_ok`,
+     * `<name>_run_err` and the timer Msg `<name>_deadline`. Omit it and they are
+     * `resilient_run`, `resilient_run_ok`, `resilient_run_err` and
+     * `deadline_exceeded`. Name a knob when a machine holds more than one, so
+     * each settles into its own `update` cell with its own answer type.
+     */
+    readonly name?: N;
     /** The pure decider for the no-key and budget-spent paths. Absent → those settle as an error. */
     readonly fallback?: JevFallback<Q>;
     /** Backoff policy, composed into `../../resilience/resilient-call`. Omit → no backoff. */
@@ -455,9 +463,10 @@ declare function offlineJevAnswer<Q extends JevQuestionMap>(request: JevRequest<
  * channels are types on the constructor rather than a convention). It is
  * resilient-call's `runCmdDef` specialized to this door's input and result, the
  * same way `../../idempotency/idempotent-intake` mints its defs per knob: `Q` is
- * a type parameter, so the def is a factory and not a module constant.
+ * a type parameter, so the def is a factory and not a module constant. `name`
+ * is the knob's name; omit it for the `resilient` family.
  */
-declare function jevAskCmdDef<Q extends JevQuestionMap>(): CmdDef<"resilient_run", {
+declare function jevAskCmdDef<Q extends JevQuestionMap, N extends string = DefaultResilientName>(name?: N): CmdDef<`${N}_run`, {
     readonly key: string;
     readonly input: JevRequest<Q>;
 }, JevOk<Q>, {
@@ -467,18 +476,21 @@ declare function jevAskCmdDef<Q extends JevQuestionMap>(): CmdDef<"resilient_run
     readonly [detail: string]: unknown;
     readonly _tag: "port_rejected";
 }>;
-/** The Cmd the verbs emit — `resilient_run` carrying the request. */
-type JevAskCmd<Q extends JevQuestionMap> = RunCmd<JevRequest<Q>, "resilient", JevOk<Q>>;
+/** The Cmd the verbs emit — `<name>_run` carrying the request. */
+type JevAskCmd<Q extends JevQuestionMap, N extends string = DefaultResilientName> = RunCmd<JevRequest<Q>, N, JevOk<Q>>;
 /** The success settle Msg — resilient-call's, with `value` narrowed to {@link JevOk}. */
-type JevSucceedMsg<Q extends JevQuestionMap> = SucceedMsg<JevOk<Q>>;
+type JevSucceedMsg<Q extends JevQuestionMap, N extends string = DefaultResilientName> = SucceedMsg<JevOk<Q>, N>;
 /**
  * The failure settle Msg the engine mints — resilient-call's. Its `error` is a
  * {@link JevRejected} when your handler used this door's builders; `fail`
  * reads it with {@link jevAskErrOf}.
  */
-type JevFailMsg = FailMsg;
-/** The retry / deadline timer Msg — `DeadlineExceeded`, inherited. */
-type JevTimerMsg = DeadlineExceeded;
+type JevFailMsg<N extends string = DefaultResilientName> = FailMsg<N>;
+/**
+ * The retry / deadline timer Msg — resilient-call's. `deadline_exceeded` for an
+ * unnamed knob, `<name>_deadline` for a named one.
+ */
+type JevTimerMsg<N extends string = DefaultResilientName> = ResilientTimerMsg<N>;
 /**
  * Build a jev-ask knob from `config`. `rng` is injected for the inherited retry
  * jitter (pass a fixed `() => 0` in tests to pin backoff; defaults to
@@ -489,10 +501,10 @@ type JevTimerMsg = DeadlineExceeded;
  * routes on it (see its docblock); it reimplements no backoff. `decode`,
  * `rejected` and `offline` are the pure outcome builders your handler returns.
  */
-declare function createJevAsk<Q extends JevQuestionMap>(config: JevAskConfig<Q>, rng?: () => number): {
-    name: "resilient";
+declare function createJevAsk<Q extends JevQuestionMap, N extends string = DefaultResilientName>(config: JevAskConfig<Q, N>, rng?: () => number): {
+    name: N;
     /** The `Cmd.define`d run Cmd — list it in the machine's `cmds`. */
-    run: CmdDef<"resilient_run", {
+    run: CmdDef<`${N}_run`, {
         readonly key: string;
         readonly input: JevRequest<Q>;
     }, JevOk<Q>, {
@@ -503,13 +515,13 @@ declare function createJevAsk<Q extends JevQuestionMap>(config: JevAskConfig<Q>,
         readonly _tag: "port_rejected";
     }>;
     init: () => ResilientState<JevRequest<Q>, JevOk<Q>>;
-    attempt: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, key: string, content: JevState, at: number) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    succeed: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevSucceedMsg<Q>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    fail: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevFailMsg) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    onTimer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevTimerMsg) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q>[]];
-    deadlines: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => readonly DeadlineSub[];
+    attempt: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, key: string, content: JevState, at: number) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q, N>[]];
+    succeed: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevSucceedMsg<Q, N>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q, N>[]];
+    fail: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevFailMsg<N>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q, N>[]];
+    onTimer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>, msg: JevTimerMsg<N>) => readonly [ResilientState<JevRequest<Q>, JevOk<Q>>, readonly JevAskCmd<Q, N>[]];
+    deadlines: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => readonly DeadlineSub<DeadlineNameOf<N>>[];
     /** The built-in `timer` Sub's deps — resilient-call's `timer`. */
-    timer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => TimerDeps<ResilientTimerMsg<"resilient">> | null;
+    timer: (s: ResilientState<JevRequest<Q>, JevOk<Q>>) => TimerDeps<ResilientTimerMsg<N>> | null;
     /** Your handler's outcome for an HTTP reply — {@link decodeJevReply}. */
     decode: (request: JevRequest<Q>, reply: JevHttpReply) => Outcome<JevOk<Q>, JevRejected>;
     /** Your handler's outcome when the call threw — {@link jevCallThrew}. */
@@ -523,7 +535,7 @@ declare function createJevAsk<Q extends JevQuestionMap>(config: JevAskConfig<Q>,
  * block reads well with. It is stated here so a host writes `cmd: {} as
  * JevCmd<Questions>` rather than deriving it from the knob's shape.
  */
-type JevCmd<Q extends JevQuestionMap> = JevAskCmd<Q>;
+type JevCmd<Q extends JevQuestionMap, N extends string = DefaultResilientName> = JevAskCmd<Q, N>;
 /**
  * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the slice
  * lives at `state.resilience` — resilient-call's convenience, re-typed for this

package/dist/jev/index.js

@@ -1,13 +1,13 @@
-import { createBatchWindow } from '../chunk-PQSDUX6B.js';
+import { createBatchWindow } from '../chunk-5HVKDHY6.js';
 import '../chunk-LFZUK6J2.js';
 import { createFanOut } from '../chunk-QNGYQMZB.js';
-import { runCmdDef, createResilientCall } from '../chunk-WTSOW2MD.js';
-import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-C3G2QFEZ.js';
+import { runCmdDef, createResilientCall } from '../chunk-72CN3VPY.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-TAKPC6SD.js';
 import '../chunk-VBDU4JL6.js';
 import '../chunk-4LPY67E4.js';
 import '../chunk-TXN2KFHF.js';
-import { liftSlice, readInOrder } from '../chunk-FNGZMVIT.js';
-import { describeError, Outcome } from '../chunk-AIIXV4XB.js';
+import { liftSlice, readInOrder } from '../chunk-DVNXEB7V.js';
+import { describeError, Outcome } from '../chunk-RKVUVALV.js';
 
 // src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;
@@ -257,14 +257,18 @@ function offlineJevAnswer(request, fallback) {
     source: "fallback"
   });
 }
-function jevAskCmdDef() {
-  return runCmdDef();
+function jevAskCmdDef(name) {
+  return runCmdDef(name);
 }
 function createJevAsk(config, rng = Math.random) {
   const resilientConfig = {
+    ...config.name === void 0 ? {} : { name: config.name },
     ...config.retry === void 0 ? {} : { retry: config.retry }
   };
-  const rc = createResilientCall(resilientConfig, rng);
+  const rc = createResilientCall(
+    resilientConfig,
+    rng
+  );
   const model = config.model ?? DEFAULT_JEV_MODEL;
   function liveRequest(s, key) {
     const call = s.calls[key];