@demlik/tea 0.14.0 → 0.16.0

package/dist/flow/index.d.ts

@@ -1,23 +1,21 @@
-import { R as Runtime, C as CtxArg } from '../runtime-types-LWDoi943.js';
-import { C as Cmd, S as Sub, M as Machine, i as CmdValue, a as CmdOf, b as CmdDef } from '../core-CTzMJ82M.js';
-export { B as BatchWindow, b as BatchWindowConfig, c as BatchWindowExpired, d as BatchWindowKnob, a as BatchWindowSub, e as addItem, f as batchWindowExpired, g as createBatchWindow, i as initBatchWindow, o as onWindow, s as subsFor, h as subscribeBatchWindow } from '../index-4vZzljCD.js';
-export { a as FanOutConfig, b as FanOutDone, c as FanOutFailed, d as FanOutPorts, F as FanOutState, e as createFanOut, i as initFanOut, f as isComplete } from '../index-6A7dB8f6.js';
-export { E as EndedRun, M as MonitoredRunCmd, b as MonitoredRunConfig, c as MonitoredRunPorts, a as MonitoredRunState, d as MonitoredRunTimerMsg, R as RunFailure, S as StageResult, e as createMonitoredRun, l as liftRun } from '../index-NjrT3fL2.js';
+import { R as Runtime, C as CtxArg } from '../runtime-types-CiVpC0HN.js';
+import { C as Cmd, S as Sub, M as Machine, R as RunHandlers, b as CmdDef, T as TimerDeps, c as CmdOf } from '../core-BbgtiXdg.js';
+export { B as BatchWindow, c as BatchWindowConfig, b as BatchWindowExpired, d as BatchWindowKnob, a as BatchWindowSub, e as addItem, f as batchWindowExpired, g as createBatchWindow, i as initBatchWindow, o as onWindow, s as subsFor, h as subscribeBatchWindow, t as timerFor } from '../index-_dOR3xqA.js';
+export { a as FanOutConfig, b as FanOutDone, c as FanOutFailed, d as FanOutPorts, F as FanOutState, e as createFanOut, i as initFanOut, f as isComplete } from '../index-CkFYA9Y6.js';
+export { E as EndedRun, M as MonitoredRunCmd, b as MonitoredRunConfig, a as MonitoredRunState, c as MonitoredRunTimerMsg, R as RunFailure, S as StageResult, d as createMonitoredRun, l as liftRun } from '../index-Bz5Rh9Ga.js';
 import { RetryState, AnyRetryPolicy, RetryPolicy } from '../retry-backoff/index.js';
 import { I as IdempotencyStore } from '../index-Bc40JWVl.js';
-import { a as DeadlineSub, T as TtlCache } from '../index-q0hXFeZ0.js';
-export { D as DeadlineExceeded, b as deadlineSub, s as subscribeDeadline } from '../index-q0hXFeZ0.js';
-import { C as CircuitConfig, c as RateLimitConfig, D as DeadlineConfig, d as ResilientPorts, F as FailMsg, S as SucceedMsg } from '../index-B5BZ-_cT.js';
+import { a as DeadlineSub, T as TtlCache } from '../index-Xufl55W8.js';
+import { f as CircuitConfig, l as RateLimitConfig, m as DeadlineConfig, b as ResilientTimerMsg } from '../index-Cou86-GX.js';
 import { PaginatedWalkState, PaginatedWalkTimerMsg, FetchPageCmd, PageErrMsg, PageOkMsg } from '../paginate/index.js';
-import { Q as QueueItem } from '../index-DJWIER_3.js';
-export { E as EnqueueInput } from '../index-DJWIER_3.js';
-import { D as DeliveryId, E as EffectLedgerEvent } from '../durable-effects-B0-qGQDy.js';
-export { a as EffectConfirmed, b as EffectOwed, e as emptyLedger } from '../durable-effects-B0-qGQDy.js';
+import { Q as QueueItem } from '../index-7vV8xmsD.js';
+export { E as EnqueueInput } from '../index-7vV8xmsD.js';
+import { D as DeliveryId, E as EffectLedgerEvent } from '../durable-effects-7MTK_jnj.js';
+export { a as EffectConfirmed, b as EffectOwed, e as emptyLedger } from '../durable-effects-7MTK_jnj.js';
 export { D as Debounced, d as debounce } from '../index-DHSUmQTR.js';
-export { c as SnapshotSavedMsg, S as SnapshotWriteCmd } from '../index-DMCeMPMJ.js';
-import 'better-result';
-import 'zod';
-import '../types-DP3f5NIl.js';
+export { b as SnapshotSavedMsg, S as SnapshotWriteCmd } from '../index-CjFDUBeq.js';
+import '@standard-schema/spec';
+import '../types-LxZxGYda.js';
 
 /**
  * internal/flow/await-terminal — run a ONE-SHOT / decision-procedure machine to a
@@ -45,7 +43,7 @@ import '../types-DP3f5NIl.js';
  * this helper does NOT invent one; the caller names their own terminal states.
  *
  * The optional `timeoutMs` is a plain caller-boundary timer (not an in-loop
- * progress deadline — see `../deadline` / `../with-deadline` for that shape): it
+ * progress deadline — see `../deadline` for that shape): it
  * clears on resolve and REJECTS with the `instanceof`-checkable
  * {@link TerminalTimeoutError} if the deadline elapses first, never silently
  * resolving.
@@ -100,17 +98,21 @@ declare function awaitTerminal<S, M extends {
  * on BOTH the resolve and reject paths. Wraps {@link awaitTerminal}.
  *
  * The seed carries the machine's `ctx` (conditionally optional, exactly as
- * `run`'s `ctx` — a pure machine omits it) and the `msgs` to dispatch once
- * booted. A `timeoutMs` in `opts` bounds the await identically to `awaitTerminal`.
+ * `run`'s `ctx` — a pure machine omits it), the handlers `run` takes beside the
+ * machine (`interpret`, and `subscribe` when its Subs need runners), and the
+ * `msgs` to dispatch once
+ * booted. A `timeoutMs` in `opts` bounds the await identically to
+ * `awaitTerminal`.
  *
  * @param machine    the machine to boot.
- * @param seed       `{ ctx?, msgs }` — the boot context and the seed messages.
+ * @param seed       `{ ctx?, interpret, subscribe?, msgs }` — the boot context, the
+ *                   handlers, and the seed messages.
  * @param isTerminal caller-supplied terminal predicate over the machine's state.
  * @param opts       optional bounded `timeoutMs` deadline (see {@link AwaitTerminalOptions}).
  */
 declare function runToTerminal<S, M extends {
     type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, seed: CtxArg<Ctx> & {
+}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, seed: CtxArg<Ctx> & NoInfer<RunHandlers<M, C, U, Ctx>> & {
     readonly msgs: readonly M[];
 }, isTerminal: (state: S) => boolean, opts?: AwaitTerminalOptions): Promise<S>;
 
@@ -176,7 +178,9 @@ declare function runToTerminal<S, M extends {
  *   },
  *
  *   // Subs — the knob owns the interval/backoff deadline:
- *   subscriptions: (s) => poll.subs(s.poll),
+ *   types: { ..., sub: {} as DeadlinesSub },
+ *   subs: [deadlinesSub((s) => poll.subs(s.poll))],
+ *   // at run: run(machine, { interpret, subscribe: { deadline: subscribeDeadline } })
  *
  * The cadence has exactly ONE source: the `everyMs` deadline Sub. `start`,
  * `tickResult`, and `tickErr` only RE-ARM the deadline (they emit no cadence
@@ -194,8 +198,8 @@ declare function runToTerminal<S, M extends {
  *     verb body names the global RNG). `replay` reconstructs a poll run exactly.
  *
  * NOT a substrate primitive: it depends only on sibling subpaths
- * (`../deadline`, `../retry-backoff`, `../idempotency`) and the core `Cmd` /
- * `Sub` types. Internal since #48 — not published on any subpath; reached from
+ * (`../deadline`, `../retry-backoff`, `../idempotency`) and the core `Cmd`
+ * type. Internal since #48 — not published on any subpath; reached from
  * inside the package as `internal/flow/poller`. The L1 escape hatch is those
  * three siblings threaded by hand.
  */
@@ -218,7 +222,7 @@ interface PollerConfig<State, R> {
      * The stop predicate, read against the consumer's whole Model. When it
      * returns `true`, the poller is DONE: `subs` returns `[]` (the timer
      * disarms) and no further tick is scheduled. Pure — it must not read the
-     * clock or mutate; the substrate calls it inside `subscriptions(state)`.
+     * clock or mutate; the consumer's reducer cell calls it (`untilHeld`).
      */
     readonly until: (state: State) => boolean;
     /**
@@ -335,22 +339,20 @@ type PollerGaveUp<R> = Extract<PollerState<R>, {
     phase: "gave_up";
 }>;
 /**
- * The poller Sub type — a `../deadline` Sub under a fixed id family. One id per
- * knob instance keeps the reconcile pass from churning the timer: the same id
- * across transitions means "same armed deadline", even as `nextAtMs` advances.
+ * The deadline the poller lists — a `../deadline` entry under the
+ * `poller:tick:` id family (see `pollerSubId`).
  */
 type PollerSub = DeadlineSub;
 /**
  * The knob handle returned by `createPoller`. Spread its hooks into your
  * machine: `init()` seeds the slice, `start(...)` arms the first tick,
  * `tickResult` / `tickErr` are the two update verbs, and `subs(...)` returns the
- * timer Sub while the poller is live.
+ * tick deadline while the poller is live.
  *
  * Pure-ops + subs module: there is no `handlers(ports)` cell. The poller's I/O
  * is the consumer's own `onTick` Cmd run by the consumer's `interpret` — the
- * knob never owns a port. (Compare `../deadline`, which ships a `subscribe`
- * cell; the poller reuses `../deadline`'s, so it has nothing of its own to
- * splice into `interpret`.)
+ * knob never owns a port. (Compare `../deadline`, which ships a `deadline`
+ * runner; the poller reuses it, so it has nothing of its own to hand `run`.)
  */
 interface Poller<State, R> {
     /** Seed the Model slice. Idle until `start(...)` arms the first tick. */
@@ -433,16 +435,16 @@ interface Poller<State, R> {
      */
     tickErr(state: PollerState<R>, error: unknown, at: number): readonly [PollerPolling<R> | PollerGaveUp<R>, readonly Cmd[]];
     /**
-     * The pre-wired subscriptions cell. Returns the single tick-deadline Sub
-     * while the poller is `"polling"` with an armed `nextAtMs`; returns `[]`
-     * once `"done"` / `"gave_up"` (the timer disarms) or before `start`. Assign
-     * directly: `subscriptions: (s) => poll.subs(s.poll)`.
+     * The tick deadline, listed while the poller is `"polling"` with an armed
+     * `nextAtMs`; `[]` once `"done"` / `"gave_up"` (the timer disarms) or before
+     * `start`. Declare it on the machine:
+     * `subs: [deadlinesSub((s) => poll.subs(s.poll))]`.
      *
-     * The `DeadlineSub` it returns is consumed by `../deadline`'s
-     * `subscribeDeadline` cell, which the consumer wires into `subscribe` —
-     * the poller does not redraw the timer lifecycle.
+     * The list is armed by `../deadline`'s `subscribeDeadline` runner, which the
+     * consumer passes to `run` as `subscribe.deadline` — the poller does not
+     * redraw the timer lifecycle.
      */
-    subs(state: PollerState<R>): readonly Sub[];
+    subs(state: PollerState<R>): readonly PollerSub[];
 }
 /**
  * Build a poller knob from `config`. Returns the hook bag to spread into a
@@ -583,54 +585,50 @@ interface ReconcilerState<Actual, Change, Page, Cursor = number> {
 /**
  * The actual-list page-fetch effect: the inherited `resilient_run` Cmd from
  * paginated-walk, whose `input` is the `Cursor` to fetch and whose `key` is the
- * fixed `PAGE_KEY`. The consumer's `handlers(ports)` interprets it.
+ * fixed `PAGE_KEY`. It is `Cmd.define`d; the handler you write fetches ONE page
+ * of the ACTUAL listing and returns `ok(page)` or
+ * `err({ _tag: "port_rejected", … })`.
  */
 type ScanPageCmd<Cursor> = FetchPageCmd<Cursor>;
-/** Page-settled Msgs the scan `handlers` port dispatches back (inherited verbatim). */
+/** The page-settled Msgs the engine mints from that handler's outcome. */
 type ScanPageOkMsg<Page> = PageOkMsg<Page>;
 type ScanPageErrMsg = PageErrMsg;
 /** The scan retry / deadline timer Msg — inherited from paginated-walk. */
 type ReconcilerTimerMsg = PaginatedWalkTimerMsg;
-/**
- * Ports the consumer supplies to `handlers`. `run(cursor)` fetches ONE page of
- * the ACTUAL listing for the given cursor; throwing routes to `pageErr` (and
- * thus the scan backoff). Same shape as paginated-walk's port.
- */
-interface ReconcilerPorts<Cursor, Page> extends ResilientPorts<Cursor, Page> {
-}
 /**
  * Build a reconciler knob from `config`. `rng` is injected for the underlying
  * scan-retry jitter — pass a fixed `() => 0` in tests to pin backoff; defaults
  * to `Math.random` (read at the verb boundary inside resilient-call, never in a
  * reconciler verb). Inherited straight from paginated-walk.
  *
- * Returns the uniform L2 knob contract: `init()`, the verbs `scan` / `pageOk` /
- * `pageErr` / `planned` / `applyNext` / `applied` / `onTimer`, the derived
- * `isComplete`, `subs(state)`, and `handlers(ports)`.
+ * Returns plain functions: `init()`, the verbs `scan` / `pageOk` / `pageErr` /
+ * `planned` / `applyNext` / `applied` / `onTimer`, the derived `isComplete`,
+ * `deadlines(state)` / `timer(state)`, and the scan's page-fetch Cmd def
+ * (`scanPage`) to list in the machine's `cmds`.
  */
 declare function createReconciler<Actual, Desired, Page, Change, ApplyCmd extends Cmd = Cmd, Cursor = number>(config: ReconcilerConfig<Actual, Desired, Page, Change, ApplyCmd, Cursor>, rng?: () => number): {
+    /** The scan's page-fetch Cmd def — list it in the machine's `cmds`. */
+    scanPage: CmdDef<"resilient_run", {
+        readonly key: string;
+        readonly input: Cursor;
+    }, Page, {
+        readonly [detail: string]: unknown;
+        readonly _tag: "deadline_exceeded";
+    } | {
+        readonly [detail: string]: unknown;
+        readonly _tag: "port_rejected";
+    }>;
     init: () => ReconcilerState<Actual, Change, Page, Cursor>;
     scan: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    pageOk: (s: ReconcilerState<Actual, Change, Page, Cursor>, page: Page, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
-    pageErr: (s: ReconcilerState<Actual, Change, Page, Cursor>, error: unknown, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
+    pageOk: (s: ReconcilerState<Actual, Change, Page, Cursor>, msg: ScanPageOkMsg<Page>) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
+    pageErr: (s: ReconcilerState<Actual, Change, Page, Cursor>, msg: ScanPageErrMsg) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
     planned: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number, changes?: readonly Change[]) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
     applyNext: (s: ReconcilerState<Actual, Change, Page, Cursor>, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
     applied: (s: ReconcilerState<Actual, Change, Page, Cursor>, change: Change, at: number) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
     onTimer: (s: ReconcilerState<Actual, Change, Page, Cursor>, msg: ReconcilerTimerMsg) => readonly [ReconcilerState<Actual, Change, Page, Cursor>, readonly (ApplyCmd | ScanPageCmd<Cursor>)[]];
     isComplete: (s: ReconcilerState<Actual, Change, Page, Cursor>) => boolean;
-    subs: (s: ReconcilerState<Actual, Change, Page, Cursor>) => readonly DeadlineSub[];
-    handlers: (ports: ReconcilerPorts<Cursor, Page>) => {
-        resilient_run: (cmd: CmdValue<"resilient_run", {
-            readonly key: string;
-            readonly input: Cursor;
-        }, {
-            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<Page>>;
-    };
+    deadlines: (s: ReconcilerState<Actual, Change, Page, Cursor>) => readonly DeadlineSub[];
+    timer: (s: ReconcilerState<Actual, Change, Page, Cursor>) => TimerDeps<ResilientTimerMsg<"resilient">> | null;
 };
 /**
  * Lift a knob result `[slice, cmds]` into a host `[State, cmds]` where the slice
@@ -1107,7 +1105,7 @@ declare function workflowActivityDef<A>(): CmdDef<"workflow_activity", {
     readonly id: DeliveryId;
     /** The opaque activity to perform. */
     readonly activity: A;
-}, void, never, unknown>;
+}, undefined, never>;
 type ActivityCmd<A> = CmdOf<ReturnType<typeof workflowActivityDef<A>>>;
 /**
  * Dispatch a compensation (#125). Same shape + ledger discipline as
@@ -1125,7 +1123,7 @@ declare function workflowCompensationDef<A>(): CmdDef<"workflow_compensation", {
     readonly id: DeliveryId;
     /** The opaque compensating (inverse) activity to perform. */
     readonly compensation: A;
-}, void, never, unknown>;
+}, undefined, never>;
 type CompensationCmd<A> = CmdOf<ReturnType<typeof workflowCompensationDef<A>>>;
 /** The Cmd union this module emits: forward activity dispatches AND (#125)
  *  reverse compensation dispatches. The owed/confirmed ledger events are not
@@ -1292,4 +1290,4 @@ declare function createWorkflow<A, R, F>(restore?: {
  */
 declare function foldWorkflow<A, R, F>(steps: WorkflowSteps<A>, msgs: Iterable<WorkflowMsg<R, F>>): WorkflowState<A, R, F>;
 
-export { type ActivityCmd, type ActivityErr, type ActivityOk, type AwaitTerminalOptions, type CompensatingWorkflow, type CompensationCmd, type CompensationErr, type CompensationFailedWorkflow, type CompensationOk, type CompletedStep, type CompletedWorkflow, DeadlineSub, DeliveryId, EffectLedgerEvent, type FailedCompensatedWorkflow, type FailedWorkflow, type InFlightActivity, type InFlightCompensation, type Poller, type PollerConfig, type PollerDone, type PollerGaveUp, type PollerPolling, type PollerState, type PollerSub, type ReconcilePhase, type ReconcilerConfig, type ReconcilerPorts, type ReconcilerState, type ReconcilerTimerMsg, type RunningWorkflow, type SagaConfig, type SagaPhase, type SagaState, type SagaStep, type ScanPageCmd, type ScanPageErrMsg, type ScanPageOkMsg, type StepId, TerminalTimeoutError, WORKFLOW_MSG_TYPES, WORKFLOW_STATUSES, type Workflow, type WorkflowCmd, type WorkflowMsg, type WorkflowMsgType, type WorkflowReducerStep, type WorkflowState, type WorkflowStatus, type WorkflowStep, type WorkflowSteps, awaitTerminal, createPoller, createReconciler, createSaga, createWorkflow, foldWorkflow, initSaga, isAborted, isCommitted, isCompensationFailed, isSettled, liftReconciler, routeWorkflowMsg, runToTerminal, workflowActivityDef, workflowCompensationDef };
+export { type ActivityCmd, type ActivityErr, type ActivityOk, type AwaitTerminalOptions, type CompensatingWorkflow, type CompensationCmd, type CompensationErr, type CompensationFailedWorkflow, type CompensationOk, type CompletedStep, type CompletedWorkflow, DeliveryId, EffectLedgerEvent, type FailedCompensatedWorkflow, type FailedWorkflow, type InFlightActivity, type InFlightCompensation, type Poller, type PollerConfig, type PollerDone, type PollerGaveUp, type PollerPolling, type PollerState, type PollerSub, type ReconcilePhase, type ReconcilerConfig, type ReconcilerState, type ReconcilerTimerMsg, type RunningWorkflow, type SagaConfig, type SagaPhase, type SagaState, type SagaStep, type ScanPageCmd, type ScanPageErrMsg, type ScanPageOkMsg, type StepId, TerminalTimeoutError, WORKFLOW_MSG_TYPES, WORKFLOW_STATUSES, type Workflow, type WorkflowCmd, type WorkflowMsg, type WorkflowMsgType, type WorkflowReducerStep, type WorkflowState, type WorkflowStatus, type WorkflowStep, type WorkflowSteps, awaitTerminal, createPoller, createReconciler, createSaga, createWorkflow, foldWorkflow, initSaga, isAborted, isCommitted, isCompensationFailed, isSettled, liftReconciler, routeWorkflowMsg, runToTerminal, workflowActivityDef, workflowCompensationDef };

package/dist/flow/index.js

@@ -1,19 +1,21 @@
-export { addItem, batchWindowExpired, createBatchWindow, initBatchWindow, onWindow, subsFor, subscribeBatchWindow } from '../chunk-F7FMAWLA.js';
+import { createPaginatedWalk, PAGE_KEY } from '../chunk-NSIAORRY.js';
+export { addItem, batchWindowExpired, createBatchWindow, initBatchWindow, onWindow, subsFor, subscribeBatchWindow, timerFor } from '../chunk-MVZS5FDM.js';
 export { debounce } from '../chunk-LFZUK6J2.js';
-import { createPaginatedWalk, PAGE_KEY } from '../chunk-I5MQMJDW.js';
 import { pendingEffectsLedger, foldLedger, survivingEffects } from '../chunk-6IQPODUF.js';
 export { emptyLedger } from '../chunk-6IQPODUF.js';
-export { createMonitoredRun, liftRun } from '../chunk-HYDWG35Q.js';
-export { createFanOut, initFanOut, isComplete } from '../chunk-MYXFNWAJ.js';
+export { createMonitoredRun, liftRun } from '../chunk-7MGXQZPW.js';
+import '../chunk-CIHSHLQX.js';
+export { createFanOut, initFanOut, isComplete } from '../chunk-QNGYQMZB.js';
 import { idempotencyMemory } from '../chunk-PR6TB3BL.js';
 import { queueAdapter } from '../chunk-TXN2KFHF.js';
-import '../chunk-HUKZQX6U.js';
-import '../chunk-AQ6ZIMEA.js';
+import '../chunk-6NG4V5SB.js';
 import { asRng, defaultRetryPolicy, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-VBDU4JL6.js';
-import { deadlineSub, initCache, get, set } from '../chunk-F2US5BW6.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-F2US5BW6.js';
-import { run, Cmd } from '../chunk-RQULHGYH.js';
-import { z } from 'zod';
+import { undefinedOnly, unchecked } from '../chunk-4LPY67E4.js';
+import { deadlineSub, initCache, get, set } from '../chunk-IVJP3GKJ.js';
+import { run } from '../chunk-WT5PBPLB.js';
+import '../chunk-5XU6ZJO2.js';
+import '../chunk-GOX2CYIM.js';
+import { Cmd } from '../chunk-CH5KTOEZ.js';
 
 // src/internal/flow/await-terminal/index.ts
 var TerminalTimeoutError = class extends Error {
@@ -67,10 +69,10 @@ function awaitTerminal(runtime, isTerminal, opts = {}) {
   });
 }
 async function runToTerminal(machine, seed, isTerminal, opts = {}) {
-  const { msgs, ...ctxArg } = seed;
+  const { msgs, ...runOpts } = seed;
   const runtime = await run(
     machine,
-    ctxArg
+    runOpts
   ).ready;
   try {
     const terminal = awaitTerminal(runtime, isTerminal, opts);
@@ -228,12 +230,13 @@ function createReconciler(config, rng = Math.random) {
     const next = { ...s, phase: "scanning", walk: w };
     return [next, cmds];
   }
-  function pageOk(s, page, at) {
+  function pageOk(s, msg) {
+    const { value: page, at } = msg;
     if (s.phase !== "scanning") {
-      const [w2] = walk.pageOk(s.walk, page, at);
+      const [w2] = walk.pageOk(s.walk, msg);
       return [withWalk(s, w2), []];
     }
-    const [w, walkCmds] = walk.pageOk(s.walk, page, at);
+    const [w, walkCmds] = walk.pageOk(s.walk, msg);
     const actual = [...s.actual, ...config.itemsOf(page)];
     const scanned = { ...s, walk: w, actual };
     const cmds = walkCmds;
@@ -243,8 +246,8 @@ function createReconciler(config, rng = Math.random) {
     }
     return [scanned, cmds];
   }
-  function pageErr(s, error, at) {
-    const [w, cmds] = walk.pageErr(s.walk, error, at);
+  function pageErr(s, msg) {
+    const [w, cmds] = walk.pageErr(s.walk, msg);
     let next = withWalk(s, w);
     if (s.phase === "scanning" && w.resilience.calls[PAGE_KEY]?.phase === "failed") {
       next = { ...next, phase: "failed" };
@@ -311,13 +314,15 @@ function createReconciler(config, rng = Math.random) {
   function isComplete2(s) {
     return s.phase === "done";
   }
-  function subs(s) {
-    return walk.subs(s.walk);
+  function deadlines(s) {
+    return walk.deadlines(s.walk);
   }
-  function handlers(ports) {
-    return walk.handlers(ports);
+  function timer(s) {
+    return walk.timer(s.walk);
   }
   return {
+    /** The scan's page-fetch Cmd def — list it in the machine's `cmds`. */
+    scanPage: walk.fetch,
     init,
     scan,
     pageOk,
@@ -327,8 +332,8 @@ function createReconciler(config, rng = Math.random) {
     applied,
     onTimer,
     isComplete: isComplete2,
-    subs,
-    handlers
+    deadlines,
+    timer
   };
 }
 function liftReconciler(state, [slice, cmds]) {
@@ -506,15 +511,15 @@ var WORKFLOW_STATUSES = new Set(
 );
 function workflowActivityDef() {
   return Cmd.define("workflow_activity", {
-    input: z.custom(),
-    ok: z.void(),
+    input: unchecked(),
+    ok: undefinedOnly,
     err: []
   });
 }
 function workflowCompensationDef() {
   return Cmd.define("workflow_compensation", {
-    input: z.custom(),
-    ok: z.void(),
+    input: unchecked(),
+    ok: undefinedOnly,
     err: []
   });
 }