@demlik/tea 0.21.0 → 0.22.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-BKJW1Kmq.js';
-import { Q as QueueItem } from '../index-Cuy1_xTh.js';
+import { a as CmdOf, b as CmdDef } from '../core-DNDAEhO2.js';
+import { Q as QueueItem } from '../index-BBLI2WWN.js';
 import '@standard-schema/spec';
-import '../runtime-types-BPKp2bGo.js';
+import '../runtime-types-CP-ykwgf.js';
 
 /**
  * A cached intake entry: either a key whose work is still in flight

package/dist/idempotency/index.js

@@ -1,8 +1,8 @@
-export { createIntake, intakeProcessDef, intakeReplayDef } from '../chunk-YCJPLPQQ.js';
+export { createIntake, intakeProcessDef, intakeReplayDef } from '../chunk-J5JNLXO7.js';
 export { evictExpired, initStore, recall, remember, seen } from '../chunk-PR6TB3BL.js';
 import '../chunk-4LPY67E4.js';
 import '../chunk-TXN2KFHF.js';
-import '../chunk-VHKDUBXC.js';
-import '../chunk-GAVLND5C.js';
+import '../chunk-BVFS3ICC.js';
+import '../chunk-A3QPMX5M.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{index-1hit3dJ9.d.ts → index-9P1PaXIV.d.ts}

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

package/dist/{index-Cuy1_xTh.d.ts → index-BBLI2WWN.d.ts}

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

package/dist/{index-Z6Uw7C9t.d.ts → index-C1WhBZ6a.d.ts}

@@ -1,4 +1,4 @@
-import { B as BootingRuntime } from './runtime-types-BPKp2bGo.js';
+import { B as BootingRuntime } from './runtime-types-CP-ykwgf.js';
 
 /**
  * A recorded run, sufficient to reproduce it via `../trace-replay`.
@@ -11,10 +11,9 @@ import { B as BootingRuntime } from './runtime-types-BPKp2bGo.js';
  */
 interface Trace<S, M> {
     /**
-     * The initial state captured at the boot observe (the transition where
-     * `msg === null`). Fed back to replay as `loaded` so `init(loaded, ctx)`
-     * reproduces the exact starting point. `null` only if the recorder attached
-     * AFTER boot (it missed the boot observe) — replay then re-runs fresh `init`.
+     * The post-init State captured by `onBoot`, used directly as the recorded
+     * replay's starting State. No init call is repeated. `null` marks a missing
+     * anchor in an older or incomplete trace; `replayTrace` refuses it.
      */
     readonly loaded: S | null;
     /** The ordered, non-null msgs as observed. The replay input sequence. */

package/dist/{index-B-VC4qjx.d.ts → index-C92SgNWz.d.ts}

@@ -1,6 +1,6 @@
-import { a as CmdOf, b as CmdDef, f as TaggedError, o as MalformedResult, T as TimerDeps, C as Cmd } from './core-BKJW1Kmq.js';
+import { a as CmdOf, b as CmdDef, f as TaggedError, o as MalformedResult, T as TimerDeps, C as Cmd } from './core-DNDAEhO2.js';
 import { RetryState, AnyRetryPolicy } from './retry-backoff/index.js';
-import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-Diyo8WBO.js';
+import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-Cg0QXnzf.js';
 
 /**
  * @packageDocumentation

package/dist/{index-CYrUWi1c.d.ts → index-CAsUE_d1.d.ts}

@@ -1,7 +1,7 @@
-import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-BKJW1Kmq.js';
-import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-DB8Yn0-K.js';
-import { D as DeadlineExceeded, a as DeadlineSub } from './index-Diyo8WBO.js';
-import { Q as QueueItem } from './index-Cuy1_xTh.js';
+import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-DNDAEhO2.js';
+import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-COeX9Bmz.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-Cg0QXnzf.js';
+import { Q as QueueItem } from './index-BBLI2WWN.js';
 
 /**
  * The monitored-run knob. EVERY field is optional:

package/dist/{index-BjwRcjBi.d.ts → index-CO34esWT.d.ts}

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

package/dist/{index-DB8Yn0-K.d.ts → index-COeX9Bmz.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-BKJW1Kmq.js';
+import { a as CmdOf, b as CmdDef, d as SettledOk, e as SettledErr, f as TaggedError, C as Cmd } from './core-DNDAEhO2.js';
 
 /**
  * The snapshot knob.
@@ -92,9 +92,10 @@ type SnapshotWriteCmd<V> = CmdOf<ReturnType<typeof snapshotWriteDef<V>>>;
  * `err({ _tag: "snapshot_load_failed", … })`.
  *
  * Distinct from `snapshot_write`: a write carries a payload OUT to the store; a
- * load asks the store to hand a payload BACK. The consumer dispatches the
- * triggering Msg once on resume (a `boot` Msg, never `init`'s rehydrate branch —
- * invariant 2), folds the recovered payload into its run slice, then continues.
+ * load asks the store to hand a payload BACK. A pure restored `init` may return
+ * resume State and Cmds, including a load Cmd from `requestLoad`. A host `boot`
+ * Msg after `run(...)` is an optional protocol; Subs are already open then.
+ * Fold the recovered payload into the run slice, then continue.
  */
 declare function snapshotLoadDef<V>(): CmdDef<"snapshot_load", {
     readonly key: string;
@@ -182,9 +183,9 @@ interface SnapshotKnob<V> {
      * un-checkpointed progress accumulated before the crash is moot — recovery
      * resumes from the last DURABLE checkpoint, so the cadence counter starts
      * fresh from there. `seq` / `lastSavedSeq` / `lastSavedAt` are preserved
-     * (they describe what is durable, which a reload does not change). Call from
-     * a `boot` Msg the host dispatches once after `run(...)`, never from `init`'s
-     * rehydrate branch (invariant 2).
+     * (they describe what is durable, which a reload does not change). A pure
+     * restored `init` may use this to return resume State and Cmds. A host `boot`
+     * Msg after `run(...)` is an optional protocol; Subs are already open then.
      *
      * Returns the reducer-cell shape `readonly [SnapshotState, readonly Cmd[]]`
      * (with `Cmd.none` — a resume emits nothing) so it drops straight into a
@@ -196,8 +197,9 @@ interface SnapshotKnob<V> {
      * `snapshot_load` Cmd carrying the configured `key`; returns the slice
      * UNCHANGED (a read decides nothing about the cadence bookkeeping — only the
      * later `snapshot_load_ok` fold, via `boot`, touches the slice). This is the
-     * entry point of the recovery loop: the consumer dispatches a `boot` Msg once
-     * after `run(...)` and folds `requestLoad` there.
+     * entry point of the recovery loop: call from pure restored `init` to return
+     * resume State and the load Cmd, or from an optional host `boot` Msg after
+     * `run(...)`, when Subs are already open.
      */
     requestLoad(state: SnapshotState): readonly [SnapshotState, readonly SnapshotLoadCmd<V>[]];
 }

package/dist/{index-Diyo8WBO.d.ts → index-Cg0QXnzf.d.ts}

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

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { B as BootingRuntime, R as Runtime } from './runtime-types-BPKp2bGo.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 DrainTimeoutNotice, i as DriveFailedError, j as DriveStalledError, E as EngineRun, k as FencedRead, F as FencedStore, l as FoldRefusal, I as IdentityDropNotice, m as MachineTypes, M as Migrated, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, n as Refusal, d as RunHandle, o as RunOptions, p as RuntimeDiscardNotice, q as RuntimeDiscardedError, r as RuntimeErrorContext, s as RuntimeErrorPhase, t as RuntimeRef, u as Schema, S as Store, v as StoreConflictError, w as StoreRefusedError, a as Supervision, x as SupervisionStrategy, y as TelemetryEvent, T as TelemetrySink, _ as __resetPortRegistry, z as absurd, A as asReducer, G as defineMachine, H as definePort, J as isFencedStore, K as noop, L as refuse, N as replay, U as schemaMigrate, V as tryApplyCell, W as tryFoldMsgs, X as tryInterpret, Y as wrapDetached } from './runtime-types-BPKp2bGo.js';
-import { C as Cmd, c as Sub, M as Machine, P as Port, m as DepKeyedSub, D as Dispose } from './core-BKJW1Kmq.js';
-export { A as AnyCmdDef, w as AsyncSchemaError, B as BuiltinSub, r as BuiltinSubType, b as CmdDef, k as CmdInput, a as CmdOf, v as CmdValue, q as DeclaredErrorsOf, u 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, o as MalformedResult, N as NoCellError, J as NoCtx, t as OkOf, p 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, l as SubId, S as Subscribe, V as SubscribeArg, X as SyncReturn, s as Tagged, f as TaggedError, T as TimerDeps, n 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-BKJW1Kmq.js';
-import { S as SubscribeHandler } from './types-BiXj7k_k.js';
+import { B as BootingRuntime, R as Runtime } from './runtime-types-CP-ykwgf.js';
+export { a as BootedRunHandle, f as Branded, C as CtxArg, D as DeletableStore, g as DispatchDiscardedError, d as DispatchSettle, h as DisposeTimeoutNotice, i as DrainTimeoutNotice, j as DriveFailedError, k as DriveStalledError, E as EngineRun, l as FencedRead, F as FencedStore, m as FoldRefusal, I as IdentityDropNotice, n as MachineTypes, M as Migrated, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, o as Refusal, e as RunHandle, p as RunOptions, q as RuntimeDiscardNotice, r as RuntimeDiscardedError, s as RuntimeErrorContext, t as RuntimeErrorPhase, u as RuntimeRef, v as Schema, b as Store, S as StoreAndOnError, w as StoreConflictError, x as StoreRefusedError, y as SubFailedError, c as Supervision, z as SupervisionStrategy, A as TelemetryEvent, T as TelemetrySink, U as UnfencedStore, _ as __resetPortRegistry, G as absurd, H as asReducer, J as defineMachine, K as definePort, L as isFencedStore, N as noop, V as refuse, W as replay, X as schemaMigrate, Y as tryApplyCell, Z as tryFoldMsgs, $ as tryInterpret, a0 as wrapDetached } from './runtime-types-CP-ykwgf.js';
+import { C as Cmd, c as Sub, M as Machine, P as Port, m as DepKeyedSub, D as Dispose } from './core-DNDAEhO2.js';
+export { A as AnyCmdDef, w as AsyncSchemaError, B as BuiltinSub, r as BuiltinSubType, b as CmdDef, k as CmdInput, a as CmdOf, v as CmdValue, q as DeclaredErrorsOf, u 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, o as MalformedResult, N as NoCellError, J as NoCtx, t as OkOf, p 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, l as SubId, S as Subscribe, V as SubscribeArg, X as SyncReturn, s as Tagged, f as TaggedError, T as TimerDeps, n 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-DNDAEhO2.js';
+import { S as SubscribeHandler } from './types-S53WDy_h.js';
 import '@standard-schema/spec';
 
 /**

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-VHKDUBXC.js';
-export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DrainTimeoutNotice, 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-GAVLND5C.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-BVFS3ICC.js';
+export { AsyncSchemaError, Cmd, DispatchDiscardedError, DisposeTimeoutNotice, DrainTimeoutNotice, DriveFailedError, DriveStalledError, IdentityDropNotice, NoCellError, Outcome, OutcomeContractError, PortNameCollisionError, QuiescenceTimeoutError, Refusal, RuntimeDiscardNotice, RuntimeDiscardedError, StoreConflictError, StoreRefusedError, SubFailedError, 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-A3QPMX5M.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/jev/index.d.ts

@@ -1,13 +1,13 @@
-import { O as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, m as DepKeyedSub, n as TimerSub } from '../core-BKJW1Kmq.js';
+import { O as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, m as DepKeyedSub, n as TimerSub } from '../core-DNDAEhO2.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-Diyo8WBO.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-B-VC4qjx.js';
-import { S as SubscribeHandler } from '../types-BiXj7k_k.js';
-import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-BjwRcjBi.js';
-import { F as FanOutState } from '../index-1hit3dJ9.js';
+import { a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-Cg0QXnzf.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-C92SgNWz.js';
+import { S as SubscribeHandler } from '../types-S53WDy_h.js';
+import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-CO34esWT.js';
+import { F as FanOutState } from '../index-9P1PaXIV.js';
 import '@standard-schema/spec';
-import '../index-Cuy1_xTh.js';
-import '../runtime-types-BPKp2bGo.js';
+import '../index-BBLI2WWN.js';
+import '../runtime-types-CP-ykwgf.js';
 
 /**
  * @packageDocumentation

package/dist/jev/index.js

@@ -1,13 +1,13 @@
-import { createBatchWindow } from '../chunk-ZV4WGW74.js';
+import { createBatchWindow } from '../chunk-R5NXOPL2.js';
 import '../chunk-LFZUK6J2.js';
 import { createFanOut } from '../chunk-QNGYQMZB.js';
-import { runCmdDef, createResilientCall } from '../chunk-MBQR3LFW.js';
-import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-QIE4Y6BK.js';
+import { runCmdDef, createResilientCall } from '../chunk-NFOGYDRS.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-UGTC33VH.js';
 import '../chunk-VBDU4JL6.js';
 import '../chunk-4LPY67E4.js';
 import '../chunk-TXN2KFHF.js';
-import { liftSlice, readInOrder } from '../chunk-VHKDUBXC.js';
-import { describeError, Outcome } from '../chunk-GAVLND5C.js';
+import { liftSlice, readInOrder } from '../chunk-BVFS3ICC.js';
+import { describeError, Outcome } from '../chunk-A3QPMX5M.js';
 
 // src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;

package/dist/laws-DTtCDDlU.d.ts

@@ -0,0 +1,135 @@
+import { C as Cmd, c as Sub, M as Machine } from './core-DNDAEhO2.js';
+
+/**
+ * One unit in a fold trace — the four pieces of data a property
+ * invariant typically asserts on. `prev` is the state before the msg
+ * applied; `next` is the state after; `cmds` is the cmds emitted by this
+ * single step (NOT the running total).
+ */
+interface Step<S, M, C> {
+    readonly prev: S;
+    readonly msg: M;
+    readonly next: S;
+    readonly cmds: readonly C[];
+}
+/**
+ * What {@link foldEvents} hands back: every state in order, one {@link Step} per
+ * Msg, the final state, and the Cmds `init` sent. A law reads one of these.
+ */
+interface Fold<S, M, C> {
+    readonly states: readonly S[];
+    readonly steps: readonly Step<S, M, C>[];
+    readonly finalState: S;
+    readonly initCmds: readonly C[];
+}
+/**
+ * Fold a Msg sequence through a machine's pure reducer, returning the
+ * per-step trace, every state in order, the final state, and the Cmds `init`
+ * sent. Initial state comes from `replay(machine, { msgs: [], ctx, loaded })`
+ * — i.e. `machine.init(loaded ?? null, ctx)` faithfully. Init's emitted cmds
+ * are NOT included in any `Step` (they're the boot moment, not a Msg): they
+ * come back as `initCmds`, on a fresh start and on a loaded state alike.
+ *
+ * @param machine  The machine under test.
+ * @param ctx      The Ctx — typically `stubCtxThrowingProxy<Ctx>()` when
+ *                 init is pure. Pass a real ctx if init reads from it.
+ * @param loaded   Optional pre-init snapshot (the `loaded` arg to
+ *                 `machine.init`). Defaults to `null` (fresh boot).
+ * @param msgs     The Msg sequence to fold.
+ *
+ * @example
+ * ```ts
+ * import type { Machine } from "@demlik/tea";
+ * import { foldEvents } from "@demlik/tea/pbt";
+ *
+ * type State = { type: "idle" } | { type: "counting"; n: number } | { type: "stopped" };
+ * type Msg = { type: "start" } | { type: "tick" } | { type: "stop" };
+ * interface Ctx { readonly tabId: number }
+ * declare const machine: Machine<State, Msg, never, never, Ctx>;
+ * declare const ctx: Ctx;
+ *
+ * const { states, steps, finalState } = foldEvents(machine, ctx, null, [
+ *   { type: "start" }, { type: "tick" }, { type: "stop" },
+ * ]);
+ * // steps[1] = { prev: { type: "counting", n: 0 }, msg: { type: "tick" }, ... }
+ * ```
+ */
+declare function foldEvents<S, M extends {
+    type: string;
+}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, ctx: NoInfer<Ctx>, loaded: NoInfer<S> | null, msgs: readonly NoInfer<M>[]): Fold<S, M, C>;
+
+/**
+ * What a broken law says. `report` names the fold that broke it. `reason` is the
+ * string the check returned to say why, or `null` when it returned `false`.
+ *
+ * @experimental
+ */
+interface LawBreak {
+    readonly report: string;
+    readonly reason: string | null;
+}
+/**
+ * The law `propertyTerminates` runs: the fold's final state is one `terminal`
+ * accepts. `terminal` also gets the Cmds `init` sent.
+ *
+ * @example
+ * ```ts
+ * import type { Machine } from "@demlik/tea";
+ * import { foldEvents, lawTerminates } from "@demlik/tea/pbt";
+ *
+ * type State = { type: "idle" } | { type: "done" };
+ * type Msg = { type: "finish" };
+ * declare const machine: Machine<State, Msg, never, never, object>;
+ *
+ * const fold = foldEvents(machine, {}, null, [{ type: "finish" }]);
+ * lawTerminates(fold, (s) => s.type === "done"); // null when it holds
+ * ```
+ *
+ * @experimental
+ */
+declare function lawTerminates<S, M, C>(fold: Fold<S, M, C>, terminal: (state: NoInfer<S>, initCmds: readonly NoInfer<C>[]) => boolean): LawBreak | null;
+/**
+ * The law `propertyInvariant` runs: `invariant` holds on every step of the fold.
+ * Return `true` or `null` to accept, `false` or a string saying why to break. It
+ * stops at the first step that breaks, and the report names that step. The second
+ * argument is the Cmds `init` sent.
+ *
+ * @example
+ * ```ts
+ * import type { Machine } from "@demlik/tea";
+ * import { foldEvents, lawInvariant } from "@demlik/tea/pbt";
+ *
+ * type State = { readonly n: number };
+ * type Msg = { type: "inc" };
+ * declare const machine: Machine<State, Msg, never, never, object>;
+ *
+ * const fold = foldEvents(machine, {}, null, [{ type: "inc" }]);
+ * lawInvariant(fold, ({ prev, next }) => next.n > prev.n || "n did not grow");
+ * ```
+ *
+ * @experimental
+ */
+declare function lawInvariant<S, M, C>(fold: Fold<S, M, C>, invariant: (step: Step<NoInfer<S>, NoInfer<M>, NoInfer<C>>, initCmds: readonly NoInfer<C>[]) => boolean | string | null): LawBreak | null;
+/**
+ * The law `propertyTrace` runs: `predicate` holds on the fold's steps and final
+ * state together. Return `true` or `null` to accept, `false` or a string saying
+ * why to break. The last argument is the Cmds `init` sent.
+ *
+ * @example
+ * ```ts
+ * import type { Machine } from "@demlik/tea";
+ * import { foldEvents, lawTrace } from "@demlik/tea/pbt";
+ *
+ * type State = { type: "open" } | { type: "done" };
+ * type Msg = { type: "close" };
+ * declare const machine: Machine<State, Msg, never, never, object>;
+ *
+ * const fold = foldEvents(machine, {}, null, [{ type: "close" }]);
+ * lawTrace(fold, (steps, final) => final.type !== "done" || steps.length > 0);
+ * ```
+ *
+ * @experimental
+ */
+declare function lawTrace<S, M, C>(fold: Fold<S, M, C>, predicate: (steps: readonly Step<NoInfer<S>, NoInfer<M>, NoInfer<C>>[], finalState: NoInfer<S>, initCmds: readonly NoInfer<C>[]) => boolean | string | null): LawBreak | null;
+
+export { type Fold as F, type LawBreak as L, type Step as S, lawTerminates as a, lawTrace as b, foldEvents as f, lawInvariant as l };

package/dist/loop-DReKGV1X.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The core loop both engines run (#280, spike #264). It does five things and
+ * nothing else: it keeps one serial tail, folds a Msg into a transition, saves
+ * before any effect, reconciles the running Subs, and runs the transition's
+ * Cmds, dispatching what they return. It has no special case for any built-in.
+ *
+ * One loop, not one per engine (#283). The loop calls a handler and a runner
+ * through erased signatures and awaits a Promise either way, so an engine's
+ * own types never pass through it. The Effect engine turns each handler and
+ * runner into a fiber at its own edge, run with the services the caller
+ * provided, so Effect services (`R`) reach every handler without the loop
+ * carrying a type slot for them — the gap spike #260's generic loop left open.
+ * Sharing the loop is also what makes the two engines' traces identical: the
+ * fold, the save order and the built-ins are the same code.
+ *
+ * Everything else `run` offers is an {@link Extension} built on ten points:
+ *
+ *   1. `update`    — middleware over the fold. Returning `null` means "no
+ *                    transition": no save, no effects, no commit.
+ *   2. `interpret` — middleware over one Cmd's handler call; it maps what the
+ *                    handler returned to the Msgs to dispatch, if any.
+ *   3. `store`     — a wrapper over the store the caller handed `run`.
+ *   4. `installed` — called once a transition's State is past its save and its
+ *                    Subs are reconciled, before its first Cmd's handler starts.
+ *                    This is Elm's `view`: it never waits on a Cmd (#695).
+ *   5. `commit`    — called after a transition's effects, with the Msg and the
+ *                    committed State, even when a Cmd handler threw. Boot
+ *                    passes `undefined` for the Msg.
+ *   6. `saveFailed` — called when a transition's save rejects, before that
+ *                    rejection reaches the dispatch caller.
+ *   7. `subFailed` — called when a Sub's failure stops the run, before the
+ *                    engine is told to stop it.
+ *   8. `halted`    — called when an extension halts the run with an error.
+ *   9. `drained`   — called once no Msg can fold any more, so the State is the
+ *                    run's last: `stop()` has finished with the queue, the
+ *                    host's or the one a failure started.
+ *  10. `ctx`       — keys added to the ctx every Cmd handler receives, so a
+ *                    handler that runs another handler inside its own can reach
+ *                    the same machinery the loop applies to it.
+ *
+ * An extension may also add methods to the run handle (`handle`). Array order
+ * is nesting order: the first extension's middleware is the outermost, and
+ * `installed` and commit callbacks run first to last. `builtinExtensions`
+ * (`./builtins`) fixes that order for every engine; it is not a user-facing
+ * plugin API (#268).
+ *
+ * `stop()` is the core's own lifecycle, because the gate it drives is what every
+ * dispatch passes through: open → draining → closed, or → abandoned when
+ * `stop()` gives up on the queue (ADR 0025), never backwards.
+ */
+
+declare const post: unique symbol;
+/**
+ * What `tell` answers, at once, about the Msg it was handed. It says where the
+ * Msg stands at that moment and nothing about how it ends.
+ *
+ *   - `"queued"`: the Msg is on the receiver's line. It has not been handled.
+ *   - `"stopped"`: the receiver is stopping or has stopped, so the Msg is not on
+ *     its line and never will be.
+ *   - `"no_cell"`: the receiver's current State has no cell for the Msg, so the
+ *     Msg is not on its line. That reads the State as it is now, not the State
+ *     the Msgs already in line will leave.
+ */
+type TellAnswer = "queued" | "stopped" | "no_cell";
+/** A run handle `tell` can reach the line of. */
+interface Postable<S, M> {
+    readonly [post]: (msg: M, takes: (state: S) => boolean) => TellAnswer;
+}
+
+export type { Postable as P, TellAnswer as T };

package/dist/{machine-BuPTS1QH.d.ts → machine-C0WhOAyB.d.ts}

@@ -1,9 +1,9 @@
-import { C as Cmd, s as Tagged, I as Interpret, A as AnyCmdDef, a as CmdOf, b as CmdDef, h as Settled, t as OkOf, u as ErrOf, o as MalformedResult, O as Outcome, v as CmdValue, H as HandlerCtx, f as TaggedError, M as Machine, S as Subscribe } from './core-BKJW1Kmq.js';
-import { b as MonitoredRunState, R as RunFailure, M as MonitoredRunCmd } from './index-CYrUWi1c.js';
-import { R as RunCmd, S as SucceedMsg, F as FailMsg, b as ResilientState, r as RunCmdDef } from './index-B-VC4qjx.js';
-import { D as DeadlineExceeded, a as DeadlineSub, b as DeadlinesSub } from './index-Diyo8WBO.js';
+import { C as Cmd, s as Tagged, I as Interpret, A as AnyCmdDef, a as CmdOf, b as CmdDef, h as Settled, t as OkOf, u as ErrOf, o as MalformedResult, O as Outcome, v as CmdValue, H as HandlerCtx, f as TaggedError, M as Machine, S as Subscribe } from './core-DNDAEhO2.js';
+import { b as MonitoredRunState, R as RunFailure, M as MonitoredRunCmd } from './index-CAsUE_d1.js';
+import { R as RunCmd, S as SucceedMsg, F as FailMsg, b as ResilientState, r as RunCmdDef } from './index-C92SgNWz.js';
+import { D as DeadlineExceeded, a as DeadlineSub, b as DeadlinesSub } from './index-Cg0QXnzf.js';
 import { M as MsgType, a as MsgTypeValue } from './protocol-ClRZBhHQ.js';
-import { F as FanOutState } from './index-1hit3dJ9.js';
+import { F as FanOutState } from './index-9P1PaXIV.js';
 import { RetryPolicy, AnyRetryPolicy } from './retry-backoff/index.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 

package/dist/machine-viz/index.d.ts

@@ -1,4 +1,4 @@
-import { C as Cmd, c as Sub, M as Machine } from '../core-BKJW1Kmq.js';
+import { C as Cmd, c as Sub, M as Machine } from '../core-DNDAEhO2.js';
 import '@standard-schema/spec';
 
 /**

package/dist/machine-viz/index.js

@@ -1,5 +1,5 @@
-import '../chunk-VHKDUBXC.js';
-import { formOf, subEntriesOf, desiredSub } from '../chunk-GAVLND5C.js';
+import '../chunk-BVFS3ICC.js';
+import { formOf, subEntriesOf, desiredSub } from '../chunk-A3QPMX5M.js';
 
 // src/machine-viz/mermaid-id.ts
 function safeId(raw) {

package/dist/mem/index.d.ts

@@ -1,5 +1,5 @@
-import { M as Migrated, D as DeletableStore, F as FencedStore } from '../runtime-types-BPKp2bGo.js';
-import '../core-BKJW1Kmq.js';
+import { M as Migrated, D as DeletableStore, F as FencedStore } from '../runtime-types-CP-ykwgf.js';
+import '../core-DNDAEhO2.js';
 import '@standard-schema/spec';
 
 /**
@@ -39,7 +39,8 @@ interface MemoryStoreOptions {
      * store is a `FencedStore<S>` whose version is an in-process counter — honest
      * for this adapter, since the cell it guards is in this process too. Two
      * `run`s handed the SAME `memoryStore` are the case it catches, and it is the
-     * cheapest way to exercise the fenced path in a test.
+     * cheapest way to exercise the fenced path in a test. A run on a fenced store
+     * must be given an `onError` (see `StoreAndOnError`).
      */
     readonly fenced?: true;
 }

package/dist/mem/index.js

@@ -1,5 +1,5 @@
-import '../chunk-VHKDUBXC.js';
-import { StoreConflictError } from '../chunk-GAVLND5C.js';
+import '../chunk-BVFS3ICC.js';
+import { StoreConflictError } from '../chunk-A3QPMX5M.js';
 
 // src/mem/index.ts
 function memoryStore(initial, parse = (raw) => raw, options = {}) {

package/dist/mem/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/mem/index.ts"],"names":[],"mappings":";;;;AAsEO,SAAS,WAAA,CACd,SACA,KAAA,GAAuC,CAAC,QAAQ,GAAA,EAChD,OAAA,GAA8B,EAAC,EAC2B;AAG1D,EAAA,IAAI,OAAiB,OAAA,IAAW,IAAA;AAGhC,EAAA,IAAI,OAAA,GAAU,CAAA;AAEd,EAAA,MAAM,IAAA,GAA0B;AAAA,IAC9B,MAAM,IAAA,GAAyB;AAC7B,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,MAAM,KAAK,KAAA,EAAyB;AAClC,MAAA,IAAA,GAAO,KAAA;AACP,MAAA,OAAA,IAAW,CAAA;AAAA,IACb,CAAA;AAAA,IACA,QAAQ,GAAA,EAA2B;AACjC,MAAA,OAAO,MAAM,GAAG,CAAA;AAAA,IAClB,CAAA;AAAA,IACA,MAAM,MAAA,GAAwB;AAG5B,MAAA,IAAA,GAAO,IAAA;AACP,MAAA,OAAA,GAAU,CAAA;AAAA,IACZ;AAAA,GACF;AACA,EAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,IAAA,EAAM,OAAO,IAAA;AAEpC,EAAA,OAAO;AAAA,IACL,GAAG,IAAA;AAAA,IACH,MAAA,EAAQ,IAAA;AAAA,IACR,MAAM,UAAA,GAAyD;AAC7D,MAAA,OAAO,EAAE,GAAA,EAAK,IAAA,EAAM,OAAA,EAAQ;AAAA,IAC9B,CAAA;AAAA,IACA,MAAM,UAAA,CAAW,KAAA,EAAU,eAAA,EAA0C;AAInE,MAAA,IAAI,YAAY,eAAA,EAAiB;AAC/B,QAAA,MAAM,IAAI,kBAAA,CAAmB,eAAA,EAAiB,OAAO,CAAA;AAAA,MACvD;AACA,MAAA,IAAA,GAAO,KAAA;AACP,MAAA,OAAA,IAAW,CAAA;AACX,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AACF","file":"index.js","sourcesContent":["/**\n * @packageDocumentation\n * @demlik/tea/mem — in-memory `Store<S>` adapter for `@demlik/tea`.\n *\n * The standard test adapter — used everywhere a Worker or DO would be\n * overkill. Mirrors the source-only convention from `packages/widget-engine`\n * and `packages/tea` (no build step).\n *\n * Reference semantics, NOT deep-clone semantics:\n *   - `save(state)` stores the reference; subsequent mutations to that\n *     reference by the caller are observable through later `load()` calls.\n *   - `load()` returns the stored reference; mutations made through it are\n *     observable on the next `load()`.\n *\n * This matches what a real KV/DO `get()` would NOT do (those serialize +\n * deserialize), but it also matches what an in-memory cache obviously does.\n * Adding a deep clone here would lie about the boundary and impose a JSON\n * round-trip on every test. Tests that need fresh copies should clone at the\n * call site.\n *\n * Boundary parse (invariant 8): `Store<S>` requires `migrate(raw)`. For\n * `memoryStore` we ship a permissive identity-default — `(raw) => raw as\n * S | null` — because this adapter is a degenerate same-process boundary:\n * there is no serialization, the reference we read is structurally the\n * reference we wrote. The `as` cast here is the documented exception to the\n * invariant-8 no-`as` rule, scoped to the parameter default. Callers that\n * want strict parsing (e.g. a test that hand-seeds the cell from outside)\n * may pass an explicit `parse` to override.\n */\n\nimport type { DeletableStore, FencedStore, Migrated } from \"../index\";\nimport { StoreConflictError } from \"../index\";\n\n/** Options for {@link memoryStore}. */\nexport interface MemoryStoreOptions {\n  /**\n   * Refuse a second live writer (#143). With `{ fenced: true }` the returned\n   * store is a `FencedStore<S>` whose version is an in-process counter — honest\n   * for this adapter, since the cell it guards is in this process too. Two\n   * `run`s handed the SAME `memoryStore` are the case it catches, and it is the\n   * cheapest way to exercise the fenced path in a test.\n   */\n  readonly fenced?: true;\n}\n\n/**\n * Build an in-memory `Store<S>`.\n *\n * @param initial - optional seed value. `undefined` and explicit `null` both\n *   mean \"no seed\"; `load()` resolves with `null` until the first `save()`.\n *   A concrete `S` seed is returned by `load()` until overwritten.\n * @param parse - optional boundary parse for the `Store<S>.migrate` contract.\n *   Defaults to identity (`(raw) => raw as S | null`) — honest for this\n *   adapter's degenerate same-process boundary. Pass an explicit parser when\n *   the test wants to reject seeded shapes that don't match `S`.\n */\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse?: (raw: unknown) => Migrated<S>,\n): DeletableStore<S>;\nexport function memoryStore<S>(\n  initial: S | null | undefined,\n  parse: ((raw: unknown) => Migrated<S>) | undefined,\n  options: MemoryStoreOptions & { readonly fenced: true },\n): FencedStore<S> & DeletableStore<S>;\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse?: (raw: unknown) => Migrated<S>,\n  options?: MemoryStoreOptions,\n): DeletableStore<S> | (FencedStore<S> & DeletableStore<S>);\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse: (raw: unknown) => Migrated<S> = (raw) => raw as S | null,\n  options: MemoryStoreOptions = {},\n): DeletableStore<S> | (FencedStore<S> & DeletableStore<S>) {\n  // Single internal cell — `undefined` and `null` collapse to one\n  // representation so the load site is branchless.\n  let cell: S | null = initial ?? null;\n  // The version the cell was last written at. A never-written cell reads `0`,\n  // matching `fileStore`'s absent stamp.\n  let version = 0;\n\n  const base: DeletableStore<S> = {\n    async load(): Promise<unknown> {\n      return cell;\n    },\n    async save(state: S): Promise<void> {\n      cell = state;\n      version += 1;\n    },\n    migrate(raw: unknown): Migrated<S> {\n      return parse(raw);\n    },\n    async delete(): Promise<void> {\n      // Back to never-written: an empty cell at version `0`. The seed is gone\n      // too — `load()` answers what an unseeded store answers.\n      cell = null;\n      version = 0;\n    },\n  };\n  if (options.fenced !== true) return base;\n\n  return {\n    ...base,\n    fenced: true,\n    async loadFenced(): Promise<{ raw: unknown; version: number }> {\n      return { raw: cell, version };\n    },\n    async saveFenced(state: S, expectedVersion: number): Promise<number> {\n      // No lock: the whole store is one process's memory, and this body has no\n      // await before the compare, so nothing can interleave between the check\n      // and the write.\n      if (version !== expectedVersion) {\n        throw new StoreConflictError(expectedVersion, version);\n      }\n      cell = state;\n      version += 1;\n      return version;\n    },\n  };\n}\n"]}
+{"version":3,"sources":["../../src/mem/index.ts"],"names":[],"mappings":";;;;AAuEO,SAAS,WAAA,CACd,SACA,KAAA,GAAuC,CAAC,QAAQ,GAAA,EAChD,OAAA,GAA8B,EAAC,EAC2B;AAG1D,EAAA,IAAI,OAAiB,OAAA,IAAW,IAAA;AAGhC,EAAA,IAAI,OAAA,GAAU,CAAA;AAEd,EAAA,MAAM,IAAA,GAA0B;AAAA,IAC9B,MAAM,IAAA,GAAyB;AAC7B,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,MAAM,KAAK,KAAA,EAAyB;AAClC,MAAA,IAAA,GAAO,KAAA;AACP,MAAA,OAAA,IAAW,CAAA;AAAA,IACb,CAAA;AAAA,IACA,QAAQ,GAAA,EAA2B;AACjC,MAAA,OAAO,MAAM,GAAG,CAAA;AAAA,IAClB,CAAA;AAAA,IACA,MAAM,MAAA,GAAwB;AAG5B,MAAA,IAAA,GAAO,IAAA;AACP,MAAA,OAAA,GAAU,CAAA;AAAA,IACZ;AAAA,GACF;AACA,EAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,IAAA,EAAM,OAAO,IAAA;AAEpC,EAAA,OAAO;AAAA,IACL,GAAG,IAAA;AAAA,IACH,MAAA,EAAQ,IAAA;AAAA,IACR,MAAM,UAAA,GAAyD;AAC7D,MAAA,OAAO,EAAE,GAAA,EAAK,IAAA,EAAM,OAAA,EAAQ;AAAA,IAC9B,CAAA;AAAA,IACA,MAAM,UAAA,CAAW,KAAA,EAAU,eAAA,EAA0C;AAInE,MAAA,IAAI,YAAY,eAAA,EAAiB;AAC/B,QAAA,MAAM,IAAI,kBAAA,CAAmB,eAAA,EAAiB,OAAO,CAAA;AAAA,MACvD;AACA,MAAA,IAAA,GAAO,KAAA;AACP,MAAA,OAAA,IAAW,CAAA;AACX,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AACF","file":"index.js","sourcesContent":["/**\n * @packageDocumentation\n * @demlik/tea/mem — in-memory `Store<S>` adapter for `@demlik/tea`.\n *\n * The standard test adapter — used everywhere a Worker or DO would be\n * overkill. Mirrors the source-only convention from `packages/widget-engine`\n * and `packages/tea` (no build step).\n *\n * Reference semantics, NOT deep-clone semantics:\n *   - `save(state)` stores the reference; subsequent mutations to that\n *     reference by the caller are observable through later `load()` calls.\n *   - `load()` returns the stored reference; mutations made through it are\n *     observable on the next `load()`.\n *\n * This matches what a real KV/DO `get()` would NOT do (those serialize +\n * deserialize), but it also matches what an in-memory cache obviously does.\n * Adding a deep clone here would lie about the boundary and impose a JSON\n * round-trip on every test. Tests that need fresh copies should clone at the\n * call site.\n *\n * Boundary parse (invariant 8): `Store<S>` requires `migrate(raw)`. For\n * `memoryStore` we ship a permissive identity-default — `(raw) => raw as\n * S | null` — because this adapter is a degenerate same-process boundary:\n * there is no serialization, the reference we read is structurally the\n * reference we wrote. The `as` cast here is the documented exception to the\n * invariant-8 no-`as` rule, scoped to the parameter default. Callers that\n * want strict parsing (e.g. a test that hand-seeds the cell from outside)\n * may pass an explicit `parse` to override.\n */\n\nimport type { DeletableStore, FencedStore, Migrated } from \"../index\";\nimport { StoreConflictError } from \"../index\";\n\n/** Options for {@link memoryStore}. */\nexport interface MemoryStoreOptions {\n  /**\n   * Refuse a second live writer (#143). With `{ fenced: true }` the returned\n   * store is a `FencedStore<S>` whose version is an in-process counter — honest\n   * for this adapter, since the cell it guards is in this process too. Two\n   * `run`s handed the SAME `memoryStore` are the case it catches, and it is the\n   * cheapest way to exercise the fenced path in a test. A run on a fenced store\n   * must be given an `onError` (see `StoreAndOnError`).\n   */\n  readonly fenced?: true;\n}\n\n/**\n * Build an in-memory `Store<S>`.\n *\n * @param initial - optional seed value. `undefined` and explicit `null` both\n *   mean \"no seed\"; `load()` resolves with `null` until the first `save()`.\n *   A concrete `S` seed is returned by `load()` until overwritten.\n * @param parse - optional boundary parse for the `Store<S>.migrate` contract.\n *   Defaults to identity (`(raw) => raw as S | null`) — honest for this\n *   adapter's degenerate same-process boundary. Pass an explicit parser when\n *   the test wants to reject seeded shapes that don't match `S`.\n */\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse?: (raw: unknown) => Migrated<S>,\n): DeletableStore<S>;\nexport function memoryStore<S>(\n  initial: S | null | undefined,\n  parse: ((raw: unknown) => Migrated<S>) | undefined,\n  options: MemoryStoreOptions & { readonly fenced: true },\n): FencedStore<S> & DeletableStore<S>;\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse?: (raw: unknown) => Migrated<S>,\n  options?: MemoryStoreOptions,\n): DeletableStore<S> | (FencedStore<S> & DeletableStore<S>);\nexport function memoryStore<S>(\n  initial?: S | null,\n  parse: (raw: unknown) => Migrated<S> = (raw) => raw as S | null,\n  options: MemoryStoreOptions = {},\n): DeletableStore<S> | (FencedStore<S> & DeletableStore<S>) {\n  // Single internal cell — `undefined` and `null` collapse to one\n  // representation so the load site is branchless.\n  let cell: S | null = initial ?? null;\n  // The version the cell was last written at. A never-written cell reads `0`,\n  // matching `fileStore`'s absent stamp.\n  let version = 0;\n\n  const base: DeletableStore<S> = {\n    async load(): Promise<unknown> {\n      return cell;\n    },\n    async save(state: S): Promise<void> {\n      cell = state;\n      version += 1;\n    },\n    migrate(raw: unknown): Migrated<S> {\n      return parse(raw);\n    },\n    async delete(): Promise<void> {\n      // Back to never-written: an empty cell at version `0`. The seed is gone\n      // too — `load()` answers what an unseeded store answers.\n      cell = null;\n      version = 0;\n    },\n  };\n  if (options.fenced !== true) return base;\n\n  return {\n    ...base,\n    fenced: true,\n    async loadFenced(): Promise<{ raw: unknown; version: number }> {\n      return { raw: cell, version };\n    },\n    async saveFenced(state: S, expectedVersion: number): Promise<number> {\n      // No lock: the whole store is one process's memory, and this body has no\n      // await before the compare, so nothing can interleave between the check\n      // and the write.\n      if (version !== expectedVersion) {\n        throw new StoreConflictError(expectedVersion, version);\n      }\n      cell = state;\n      version += 1;\n      return version;\n    },\n  };\n}\n"]}