@demlik/tea 0.16.0 → 0.18.0

package/dist/testing/promise/index.js

@@ -0,0 +1,37 @@
+import { driveContractOf, driveLoop, DEFAULT_MAX_ROUNDS } from '../../chunk-H3MWNH7A.js';
+export { DEFAULT_MAX_ROUNDS, DriveNoHandlerError, DriveRoundsExceededError, driveTraceOf } from '../../chunk-H3MWNH7A.js';
+import '../../chunk-JVKU2UQC.js';
+import '../../chunk-FNGZMVIT.js';
+import { cmdEdge, Outcome } from '../../chunk-AIIXV4XB.js';
+
+// src/testing/promise/drive.ts
+async function drive(machine, initial, msg, handlers, ...[opts]) {
+  const options = opts ?? {};
+  const contract = driveContractOf(machine, options.clock ?? Date.now);
+  const noopEmit = { emit: () => {
+  } };
+  const handlerCtx = {
+    ...noopEmit,
+    ok: Outcome.ok,
+    err: Outcome.err,
+    [cmdEdge]: contract.settle,
+    ...options.ctx
+  };
+  const cells = handlers;
+  const cellFor = (type) => {
+    const cell = cells[type];
+    return cell && ((cmd, dispatch) => cell(cmd, handlerCtx, dispatch));
+  };
+  return driveLoop(
+    machine,
+    initial,
+    msg,
+    options.ctx,
+    options.maxRounds ?? DEFAULT_MAX_ROUNDS,
+    { contract, cellFor }
+  );
+}
+
+export { drive };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/testing/promise/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/testing/promise/drive.ts"],"names":[],"mappings":";;;;;;;AA+DA,eAAsB,MAOpB,OAAA,EACA,OAAA,EACA,KACA,QAAA,EAAA,GACG,CAAC,IAAI,CAAA,EAGuB;AAC/B,EAAA,MAAM,OAAA,GAAW,QAAQ,EAAC;AAK1B,EAAA,MAAM,WAAW,eAAA,CAAgB,OAAA,EAAS,OAAA,CAAQ,KAAA,IAAS,KAAK,GAAG,CAAA;AAMnE,EAAA,MAAM,QAAA,GAAwB,EAAE,IAAA,EAAM,MAAM;AAAA,EAAC,CAAA,EAAE;AAC/C,EAAA,MAAM,UAAA,GAAa;AAAA,IACjB,GAAG,QAAA;AAAA,IACH,IAAI,OAAA,CAAQ,EAAA;AAAA,IACZ,KAAK,OAAA,CAAQ,GAAA;AAAA,IACb,CAAC,OAAO,GAAG,QAAA,CAAS,MAAA;AAAA,IACpB,GAAI,OAAA,CAAQ;AAAA,GACd;AAKA,EAAA,MAAM,KAAA,GAAQ,QAAA;AAKd,EAAA,MAAM,OAAA,GAAU,CAAC,IAAA,KAA8C;AAC7D,IAAA,MAAM,IAAA,GAAO,MAAM,IAAI,CAAA;AACvB,IAAA,OAAO,SAAS,CAAC,GAAA,EAAK,aAAa,IAAA,CAAK,GAAA,EAAK,YAAY,QAAQ,CAAA,CAAA;AAAA,EACnE,CAAA;AAEA,EAAA,OAAO,SAAA;AAAA,IACL,OAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAA;AAAA,IACA,OAAA,CAAQ,GAAA;AAAA,IACR,QAAQ,SAAA,IAAa,kBAAA;AAAA,IACrB,EAAE,UAAU,OAAA;AAAQ,GACtB;AACF","file":"index.js","sourcesContent":["// ---------------------------------------------------------------------------\n// `drive(machine, initial, msg, handlers, opts)` for the Promise engine: the\n// runtime's own Cmd→handler→settle-Msg loop, said once, for a test.\n//\n// The loop is `../drive-loop.ts`, shared with the Effect `drive`. What this\n// file adds is the Promise edge: each handler is awaited with the ctx `run`\n// would hand it, and its `dispatch`. There is no `Runtime` here and no Sub is\n// run; the only impure thing it does is `await` the handler the caller handed\n// it.\n//\n// Prior art converged on the same answer: Temporal's `TestWorkflowEnvironment`\n// hands a test the event history rather than the final result, and Effect's\n// `TestClock` runs make the effect log inspectable rather than opaque.\n// ---------------------------------------------------------------------------\n\nimport {\n  type Cmd,\n  type Interpret,\n  type Machine,\n  Outcome,\n  type PortEmitter,\n  type Sub,\n} from \"../../index\";\nimport { cmdEdge } from \"../../pure/core\";\nimport {\n  DEFAULT_MAX_ROUNDS,\n  type DriveCell,\n  type DriveOptions,\n  type DriveResult,\n  driveContractOf,\n  driveLoop,\n} from \"../drive-loop\";\n\n/**\n * Drive `machine` from `initial` through `msg` against the REAL interpret\n * `handlers`, feeding every settle Msg back until the machine goes quiet, and\n * hand back the settled state together with the whole history.\n *\n * `handlers` is the same table a host hands `run` as its `interpret` (e.g.\n * a jev knob's `resilient_run` handler), so the test drives the real interpreter and\n * mocks only the port beneath it.\n *\n * One round is: fold every pending Msg, then await a handler for every Cmd\n * those folds emitted. A Msg a handler returns — or fires through its injected\n * `dispatch` — is pending for the next round. A machine that emits no Cmd for\n * its seed Msg therefore settles in ONE round and never awaits a handler at\n * all. Subs are not run.\n *\n * A `Cmd.define`d Cmd's handler is held to the engine's contract (ADR 0021):\n * its outcome is minted into `_ok` / `_err`, and a `_ok` / `_err` it builds and\n * dispatches itself is refused, failing the drive with `OutcomeContractError`\n * exactly where `run` would report it (#304). A settle it minted through\n * `cmdEdgeOf(ctx)` passes.\n *\n * The `ctx` handed to each handler is `opts.ctx` augmented with a NO-OP `emit`,\n * so a handler that emits to a `Port` runs without a live runtime; nothing here\n * observes ports. Supply your own `emit` on `ctx` to capture them.\n *\n * @throws {DriveRoundsExceededError} when the machine is still emitting work\n *   after `opts.maxRounds` rounds. It never returns a half-driven state.\n * @throws whatever a handler rejects with, unchanged — annotated with the\n *   partial trace, readable via `driveTraceOf`.\n */\nexport async function drive<\n  S,\n  M extends { type: string },\n  C extends Cmd,\n  U extends Sub,\n  Ctx,\n>(\n  machine: Machine<S, M, C, U, Ctx>,\n  initial: S,\n  msg: M,\n  handlers: Interpret<M, C, Ctx>,\n  ...[opts]: Record<never, never> extends DriveOptions<Ctx>\n    ? [opts?: DriveOptions<Ctx>]\n    : [opts: DriveOptions<Ctx>]\n): Promise<DriveResult<S, M, C>> {\n  const options = (opts ?? {}) as {\n    ctx?: Ctx;\n    maxRounds?: number;\n    clock?: () => number;\n  };\n  const contract = driveContractOf(machine, options.clock ?? Date.now);\n\n  // A handler's ctx is `Ctx & PortEmitter`, plus the `ok` / `err` builders and\n  // the edge a defined Cmd's handler is handed. The Ctx half is the caller's;\n  // the rest is the kernel's, and a driven test has no kernel — so a no-op\n  // `emit` stands in, placed FIRST so a caller's own `emit` wins.\n  const noopEmit: PortEmitter = { emit: () => {} };\n  const handlerCtx = {\n    ...noopEmit,\n    ok: Outcome.ok,\n    err: Outcome.err,\n    [cmdEdge]: contract.settle,\n    ...(options.ctx as unknown as Record<string, unknown> | undefined),\n  };\n\n  // Indexed dynamically: `Interpret`'s mapped type already proved every Cmd\n  // variant has a cell, but `cmd.type` is a union at the value level and TS\n  // cannot correlate the two sides of that index.\n  const cells = handlers as unknown as Record<\n    string,\n    | ((cmd: C, ctx: unknown, dispatch: (msg: M) => void) => Promise<unknown>)\n    | undefined\n  >;\n  const cellFor = (type: string): DriveCell<M, C> | undefined => {\n    const cell = cells[type];\n    return cell && ((cmd, dispatch) => cell(cmd, handlerCtx, dispatch));\n  };\n\n  return driveLoop(\n    machine,\n    initial,\n    msg,\n    options.ctx as Ctx,\n    options.maxRounds ?? DEFAULT_MAX_ROUNDS,\n    { contract, cellFor },\n  );\n}\n"]}

package/dist/timing/index.d.ts

@@ -1,9 +1,9 @@
 export { D as Debounced, d as debounce } from '../index-DHSUmQTR.js';
-import { C as Cmd } from '../core-BbgtiXdg.js';
-import { T as TtlCache, a as DeadlineSub } from '../index-Xufl55W8.js';
-export { D as ThrottledInputSettled, s as subscribeThrottledInput, d as throttledInputSettled } from '../index-Xufl55W8.js';
+import { C as Cmd } from '../core-Ce9ncpuv.js';
+import { T as TtlCache, a as DeadlineSub } from '../index-e36uEyl4.js';
+export { D as ThrottledInputSettled, s as subscribeThrottledInput, d as throttledInputSettled } from '../index-e36uEyl4.js';
 import '@standard-schema/spec';
-import '../types-LxZxGYda.js';
+import '../types-SzNSHKlV.js';
 
 /**
  * internal/timing/throttle — a timer-based call transformer that caps invocation

package/dist/timing/index.js

@@ -1,8 +1,8 @@
 export { debounce } from '../chunk-LFZUK6J2.js';
-import { deadlineSub, initCache, get, set } from '../chunk-IVJP3GKJ.js';
-export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-IVJP3GKJ.js';
-import '../chunk-GOX2CYIM.js';
-import '../chunk-CH5KTOEZ.js';
+import { deadlineSub, initCache, get, set } from '../chunk-C3G2QFEZ.js';
+export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-C3G2QFEZ.js';
+import '../chunk-FNGZMVIT.js';
+import '../chunk-AIIXV4XB.js';
 
 // src/internal/timing/throttle/index.ts
 function throttle(fn, ms, opts) {

package/dist/{types-LxZxGYda.d.ts → types-SzNSHKlV.d.ts}

@@ -1,4 +1,4 @@
-import { S as Sub, h as Dispose } from './core-BbgtiXdg.js';
+import { c as Sub, D as Dispose } from './core-Ce9ncpuv.js';
 
 type SubscribeHandler<S extends Sub, M, Ctx> = (sub: S, ctx: Ctx, dispatch: (msg: M) => void) => Dispose;
 

package/dist/work-queue/index.d.ts

@@ -1,7 +1,7 @@
-import { Q as QueueItem } from '../index-7vV8xmsD.js';
-export { E as EnqueueInput, a as QueueItemStatus, c as createQueue } from '../index-7vV8xmsD.js';
-import '../runtime-types-CiVpC0HN.js';
-import '../core-BbgtiXdg.js';
+import { Q as QueueItem } from '../index-DWdg7R1l.js';
+export { E as EnqueueInput, a as QueueItemStatus, c as createQueue } from '../index-DWdg7R1l.js';
+import '../runtime-types-BKg2CGMx.js';
+import '../core-Ce9ncpuv.js';
 import '@standard-schema/spec';
 
 /**

package/dist/work-queue/index.js

@@ -1,14 +1,15 @@
 import { enqueueOp, claimNextOp, markDoneOp, patchItemOp, resetRunningOp, removeOp } from '../chunk-TXN2KFHF.js';
 export { claimNextOp, enqueueOp, markDoneOp, patchItemOp, queueAdapter, removeOp, resetRunningOp } from '../chunk-TXN2KFHF.js';
+import { restore } from '../chunk-JVE2LBFJ.js';
+import '../chunk-AIIXV4XB.js';
 
 // src/internal/work-queue/index.ts
 function genId() {
   return globalThis.crypto?.randomUUID?.() ?? `q_${Date.now()}_${Math.random().toString(36).slice(2)}`;
 }
 function createQueue(store) {
-  async function loadParsed() {
-    const raw = await store.load();
-    return store.migrate(raw);
+  function loadParsed() {
+    return restore(store);
   }
   async function list() {
     return await loadParsed() ?? [];

package/dist/work-queue/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/internal/work-queue/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * internal/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.\n *\n * Two public surfaces, one shape:\n *   - `createQueue(store)` (this file) is the in-process adapter — it binds the\n *     pure ops to an injected `Store` and runs `load → mutate → save`.\n *   - `internal/work-queue/ops` (`./ops`) is the BLESSED, importable surface\n *     of those same pure ops. L2 compositions that own their own Model slice\n *     (`monitored-run`, `idempotent-intake`, …) import the ops directly and\n *     delegate status flips to them instead of re-rolling the transitions.\n * Both routes call the identical ops, so the lifecycle rules live in exactly\n * one place. This mirrors `@demlik/tea/do`'s one-shape-per-package rule.\n *\n * The package is generic in the input payload `I` (audit-specific fields go\n * here in the extension host). `output` is a free-form side-channel correlation\n * token (a backend id, URL, trace id) — typed as `string` because that's its\n * only honest type. Consumers that need structured per-item data persist it in\n * their own store and put the foreign-key string in `output`.\n */\n\nimport type { Store } from \"../../index\";\nimport {\n  claimNextOp,\n  enqueueOp,\n  markDoneOp,\n  patchItemOp,\n  removeOp,\n  resetRunningOp,\n} from \"./ops\";\n\n/**\n * Generate a queue-item id at the adapter boundary. Reads `Date.now()` and\n * `Math.random()` — impure helpers belong in the adapter (`index.ts`),\n * never in `ops.ts` (which is purely-functional by contract). Uses native\n * UUID when available, falls back to timestamp + random for environments\n * without `crypto.randomUUID`.\n */\nfunction genId(): string {\n  return (\n    globalThis.crypto?.randomUUID?.() ??\n    `q_${Date.now()}_${Math.random().toString(36).slice(2)}`\n  );\n}\n\nexport type QueueItemStatus =\n  | \"pending\"\n  | \"running\"\n  | \"done\"\n  | \"failed\"\n  | \"cancelled\";\n\n/**\n * A single queue entry. Every field is `readonly`: a persisted slice is\n * immutable, so a transition returns a NEW item (the ops always spread —\n * `{ ...item, status: … }`) rather than mutating in place. This type-enforces\n * the durability invariant the consumers already honor by convention, and\n * keeps a slice round-trippable through JSON unchanged across a reload.\n */\nexport interface QueueItem<I> {\n  readonly id: string;\n  readonly status: QueueItemStatus;\n  readonly input: I;\n  readonly enqueuedAt: number;\n  readonly startedAt?: number;\n  readonly finishedAt?: number;\n  readonly output?: string;\n  readonly error?: string;\n}\n\n/**\n * Caller-facing enqueue payload. Just `I` today — kept named so future\n * variants (priority, deferUntil, …) can grow without breaking callers.\n */\nexport type EnqueueInput<I> = I;\n\n/**\n * Adapter that binds the pure ops to an injected `Store<QueueItem<I>[]>`.\n *\n * `load → mutate → save` is the only durability discipline this package\n * imposes. The store decides what \"save\" means (chrome.storage, KV, DO\n * storage, in-memory) — that decision belongs at the caller.\n *\n * Ops that don't change the queue (e.g. `markDone` on an unknown id) skip the\n * save call so the underlying store doesn't observe a write churn.\n */\nexport function createQueue<I>(store: Store<QueueItem<I>[]>) {\n  // `Store<S>.load()` returns `unknown` (invariant 8 boundary). Route\n  // through `store.migrate(raw)` to get the typed value before any\n  // queue operation reads it — same wiring the substrate's `run()` uses at\n  // boot. The work queue is a substrate-agnostic primitive on top of\n  // `Store<S>`, so it honors the same contract.\n  async function loadParsed(): Promise<QueueItem<I>[] | null> {\n    const raw = await store.load();\n    return store.migrate(raw);\n  }\n\n  async function list(): Promise<QueueItem<I>[]> {\n    return (await loadParsed()) ?? [];\n  }\n\n  async function enqueue(input: EnqueueInput<I>): Promise<QueueItem<I>> {\n    const queue = await list();\n    const { next, item } = enqueueOp<I>(queue, input, Date.now(), genId());\n    await store.save(next);\n    return item;\n  }\n\n  async function claimNext(): Promise<QueueItem<I> | null> {\n    const queue = await list();\n    const result = claimNextOp<I>(queue, Date.now());\n    if (!result) return null;\n    await store.save(result.next);\n    return result.claimed;\n  }\n\n  // `markDone` ignores the optional second arg by design: completed runs leave\n  // the queue, and the consumer is expected to persist any output (auditId,\n  // etc.) wherever those completed records belong. Kept in the signature for\n  // call-site readability and forward-compat with `bindOutput`.\n  async function markDone(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = markDoneOp<I>(queue, id);\n    if (changed) await store.save(next);\n  }\n\n  async function markFailed(id: string, error: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"failed\",\n      finishedAt: Date.now(),\n      error,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  async function markCancelled(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"cancelled\",\n      finishedAt: Date.now(),\n    }));\n    if (changed) await store.save(next);\n  }\n\n  async function resetRunningToPending(): Promise<void> {\n    const queue = await list();\n    const { next, changed } = resetRunningOp<I>(queue);\n    if (changed) await store.save(next);\n  }\n\n  async function removeItem(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = removeOp<I>(queue, id);\n    if (changed) await store.save(next);\n  }\n\n  async function retryItem(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"pending\",\n      startedAt: undefined,\n      finishedAt: undefined,\n      error: undefined,\n      output: undefined,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  // `bindOutput` attaches a side-channel correlation token (string) to a\n  // running item without changing its status. The queue can't reach into\n  // `I` to mutate it (the substrate is domain-agnostic), so callers that\n  // need to thread a backend id / URL / trace id through the lifecycle\n  // route it here. Consumers needing structured payloads should persist\n  // them in their own store and put the foreign-key string in `output`.\n  async function bindOutput(id: string, value: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      output: value,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  return {\n    enqueue,\n    claimNext,\n    markDone,\n    markFailed,\n    markCancelled,\n    resetRunningToPending,\n    removeItem,\n    retryItem,\n    bindOutput,\n    list,\n  };\n}\n"]}
+{"version":3,"sources":["../../src/internal/work-queue/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * internal/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.\n *\n * Two public surfaces, one shape:\n *   - `createQueue(store)` (this file) is the in-process adapter — it binds the\n *     pure ops to an injected `Store` and runs `load → mutate → save`.\n *   - `internal/work-queue/ops` (`./ops`) is the BLESSED, importable surface\n *     of those same pure ops. L2 compositions that own their own Model slice\n *     (`monitored-run`, `idempotent-intake`, …) import the ops directly and\n *     delegate status flips to them instead of re-rolling the transitions.\n * Both routes call the identical ops, so the lifecycle rules live in exactly\n * one place. This mirrors `@demlik/tea/do`'s one-shape-per-package rule.\n *\n * The package is generic in the input payload `I` (audit-specific fields go\n * here in the extension host). `output` is a free-form side-channel correlation\n * token (a backend id, URL, trace id) — typed as `string` because that's its\n * only honest type. Consumers that need structured per-item data persist it in\n * their own store and put the foreign-key string in `output`.\n */\n\nimport type { Store } from \"../../index\";\nimport { restore } from \"../engine/restore\";\nimport {\n  claimNextOp,\n  enqueueOp,\n  markDoneOp,\n  patchItemOp,\n  removeOp,\n  resetRunningOp,\n} from \"./ops\";\n\n/**\n * Generate a queue-item id at the adapter boundary. Reads `Date.now()` and\n * `Math.random()` — impure helpers belong in the adapter (`index.ts`),\n * never in `ops.ts` (which is purely-functional by contract). Uses native\n * UUID when available, falls back to timestamp + random for environments\n * without `crypto.randomUUID`.\n */\nfunction genId(): string {\n  return (\n    globalThis.crypto?.randomUUID?.() ??\n    `q_${Date.now()}_${Math.random().toString(36).slice(2)}`\n  );\n}\n\nexport type QueueItemStatus =\n  | \"pending\"\n  | \"running\"\n  | \"done\"\n  | \"failed\"\n  | \"cancelled\";\n\n/**\n * A single queue entry. Every field is `readonly`: a persisted slice is\n * immutable, so a transition returns a NEW item (the ops always spread —\n * `{ ...item, status: … }`) rather than mutating in place. This type-enforces\n * the durability invariant the consumers already honor by convention, and\n * keeps a slice round-trippable through JSON unchanged across a reload.\n */\nexport interface QueueItem<I> {\n  readonly id: string;\n  readonly status: QueueItemStatus;\n  readonly input: I;\n  readonly enqueuedAt: number;\n  readonly startedAt?: number;\n  readonly finishedAt?: number;\n  readonly output?: string;\n  readonly error?: string;\n}\n\n/**\n * Caller-facing enqueue payload. Just `I` today — kept named so future\n * variants (priority, deferUntil, …) can grow without breaking callers.\n */\nexport type EnqueueInput<I> = I;\n\n/**\n * Adapter that binds the pure ops to an injected `Store<QueueItem<I>[]>`.\n *\n * `load → mutate → save` is the only durability discipline this package\n * imposes. The store decides what \"save\" means (chrome.storage, KV, DO\n * storage, in-memory) — that decision belongs at the caller.\n *\n * Ops that don't change the queue (e.g. `markDone` on an unknown id) skip the\n * save call so the underlying store doesn't observe a write churn.\n */\nexport function createQueue<I>(store: Store<QueueItem<I>[]>) {\n  // `Store<S>.load()` returns `unknown` (invariant 8 boundary). Route\n  // through `store.migrate(raw)` to get the typed value before any\n  // queue operation reads it — the same `restore` the substrate's `run()` uses\n  // at boot, so a queue it cannot read throws `StoreRefusedError` and no op\n  // saves over it. The work queue is a substrate-agnostic primitive on top of\n  // `Store<S>`, so it honors the same contract.\n  function loadParsed(): Promise<QueueItem<I>[] | null> {\n    return restore(store);\n  }\n\n  async function list(): Promise<QueueItem<I>[]> {\n    return (await loadParsed()) ?? [];\n  }\n\n  async function enqueue(input: EnqueueInput<I>): Promise<QueueItem<I>> {\n    const queue = await list();\n    const { next, item } = enqueueOp<I>(queue, input, Date.now(), genId());\n    await store.save(next);\n    return item;\n  }\n\n  async function claimNext(): Promise<QueueItem<I> | null> {\n    const queue = await list();\n    const result = claimNextOp<I>(queue, Date.now());\n    if (!result) return null;\n    await store.save(result.next);\n    return result.claimed;\n  }\n\n  // `markDone` ignores the optional second arg by design: completed runs leave\n  // the queue, and the consumer is expected to persist any output (auditId,\n  // etc.) wherever those completed records belong. Kept in the signature for\n  // call-site readability and forward-compat with `bindOutput`.\n  async function markDone(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = markDoneOp<I>(queue, id);\n    if (changed) await store.save(next);\n  }\n\n  async function markFailed(id: string, error: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"failed\",\n      finishedAt: Date.now(),\n      error,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  async function markCancelled(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"cancelled\",\n      finishedAt: Date.now(),\n    }));\n    if (changed) await store.save(next);\n  }\n\n  async function resetRunningToPending(): Promise<void> {\n    const queue = await list();\n    const { next, changed } = resetRunningOp<I>(queue);\n    if (changed) await store.save(next);\n  }\n\n  async function removeItem(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = removeOp<I>(queue, id);\n    if (changed) await store.save(next);\n  }\n\n  async function retryItem(id: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      status: \"pending\",\n      startedAt: undefined,\n      finishedAt: undefined,\n      error: undefined,\n      output: undefined,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  // `bindOutput` attaches a side-channel correlation token (string) to a\n  // running item without changing its status. The queue can't reach into\n  // `I` to mutate it (the substrate is domain-agnostic), so callers that\n  // need to thread a backend id / URL / trace id through the lifecycle\n  // route it here. Consumers needing structured payloads should persist\n  // them in their own store and put the foreign-key string in `output`.\n  async function bindOutput(id: string, value: string): Promise<void> {\n    const queue = await list();\n    const { next, changed } = patchItemOp<I>(queue, id, (item) => ({\n      ...item,\n      output: value,\n    }));\n    if (changed) await store.save(next);\n  }\n\n  return {\n    enqueue,\n    claimNext,\n    markDone,\n    markFailed,\n    markCancelled,\n    resetRunningToPending,\n    removeItem,\n    retryItem,\n    bindOutput,\n    list,\n  };\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@demlik/tea",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "TEA-faithful state machine substrate — one package, every host adapter. Core + subs + testing, plus React, Durable Object, Chrome extension, Node, in-memory, devtools, and property-testing modules as subpaths.",
   "keywords": [
     "tea",
@@ -15,7 +15,8 @@
   "homepage": "https://demlik.run",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kamp-us/demlik.git"
+    "url": "git+https://github.com/kamp-us/demlik.git",
+    "directory": "packages/tea"
   },
   "license": "MIT",
   "author": "Can Sirin",
@@ -63,6 +64,14 @@
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"
     },
+    "./testing/promise": {
+      "types": "./dist/testing/promise/index.d.ts",
+      "import": "./dist/testing/promise/index.js"
+    },
+    "./testing/effect": {
+      "types": "./dist/testing/effect/index.d.ts",
+      "import": "./dist/testing/effect/index.js"
+    },
     "./pbt": {
       "types": "./dist/pbt/index.d.ts",
       "import": "./dist/pbt/index.js"
@@ -119,6 +128,10 @@
       "types": "./dist/parity/index.d.ts",
       "import": "./dist/parity/index.js"
     },
+    "./otel": {
+      "types": "./dist/otel/index.d.ts",
+      "import": "./dist/otel/index.js"
+    },
     "./devtools/styles.css": "./dist/devtools/styles.css",
     "./package.json": "./package.json"
   },
@@ -126,14 +139,18 @@
     "@standard-schema/spec": "^1.1.0"
   },
   "peerDependencies": {
+    "@opentelemetry/api": "^1.9.0",
     "effect": "^4.0.0-rc.0",
     "fast-check": "^3 || ^4",
     "react": "^18 || ^19",
     "react-dom": "^18 || ^19",
-    "vitest": "^2 || ^3",
+    "vitest": "^2 || ^3 || ^4 || ^5",
     "ws": "^8"
   },
   "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
     "effect": {
       "optional": true
     },
@@ -155,27 +172,27 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "0.124.0",
-    "@biomejs/biome": "2.3.14",
-    "@changesets/cli": "^2.27.11",
     "@cloudflare/workers-types": "4.20260312.1",
-    "@kampus/fabrika-cli": "0.7.1",
+    "@langfuse/otel": "5.11.1",
+    "@opentelemetry/api": "1.9.1",
+    "@opentelemetry/sdk-trace-base": "2.11.0",
     "@types/chrome": "^0.1.42",
     "@types/node": "^22",
     "@types/react": "19.0.8",
     "@types/react-dom": "19.0.3",
     "@types/ws": "8.5.14",
-    "ai": "^7.0.93",
     "effect": "4.0.0-rc.117",
     "fast-check": "^3.23.0",
     "happy-dom": "^20.9.0",
+    "openai": "7.23.0",
     "react": "19.0.0",
     "react-dom": "19.0.0",
     "tsup": "^8.3.5",
     "typedoc": "0.28.20",
     "typescript": "5.7.3",
     "vite": "^8.2.1",
-    "vitest": "~3.0.7",
-    "ws": "8.18.1",
+    "vitest": "~5.0.1",
+    "ws": "^8.21.0",
     "zod": "^4.5.4"
   },
   "publishConfig": {
@@ -184,9 +201,6 @@
   "bugs": {
     "url": "https://github.com/kamp-us/demlik/issues"
   },
-  "volta": {
-    "node": "23.7.0"
-  },
   "scripts": {
     "build": "NODE_OPTIONS=--max-old-space-size=8192 tsup",
     "lint": "biome check src package.json",
@@ -199,8 +213,6 @@
     "docs:reference": "TEA_DOCS_WRITE=1 vitest run src/docs/reference/generate-reference.test.ts",
     "docs:reference:check": "pnpm run docs:reference && git diff --exit-code -- docs/reference",
     "verify-exports": "node scripts/verify-exports.mjs",
-    "verify-optional-peer-install": "node scripts/verify-optional-peer-install.mjs",
-    "check:merge-markers": "node scripts/check-merge-markers.mjs",
-    "release": "changeset"
+    "verify-optional-peer-install": "node scripts/verify-optional-peer-install.mjs"
   }
 }

package/dist/chunk-5XU6ZJO2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internal/engine/builtins.ts","../src/internal/engine/loop.ts"],"names":[],"mappings":"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","file":"chunk-5XU6ZJO2.js","sourcesContent":["/**\n * tea's built-ins, each one an {@link Extension} of the core loop (`./loop`,\n * #280). None is a public plugin API (#268): each engine's `run` builds them\n * from its options through {@link builtinExtensions}, which fixes their order.\n */\n\nimport type { AnyCmdDef, Identity, Port } from \"../../pure/core\";\nimport {\n  checkedStep,\n  cmdEdge,\n  cmdEdgeOver,\n  Outcome,\n  structuralHash,\n} from \"../../pure/core\";\nimport type {\n  Store,\n  Supervision,\n  TelemetryEvent,\n  TelemetrySink,\n} from \"../../runtime-types\";\nimport { IdentityDropNotice, isFencedStore } from \"../../runtime-types\";\nimport type { Extension, ExtensionFactory, LoopServices } from \"./loop\";\n\ntype AnyExtension<S, M, C> = ExtensionFactory<S, M, C>;\n\n// === update middleware ===\n\n/**\n * Supervision: a throw from the fold (the reducer, or any update middleware\n * inside this one) is reported under `\"reduce\"` for every strategy, then\n * `restart` commits the host's rehydrated State with no Cmds, `escalate`\n * rethrows with the runtime still live, and `stop` (the default) halts the gate\n * and rethrows, so THIS dispatch rejects too.\n */\nexport function supervision<S, M extends { type: string }, C>(\n  declared: Supervision<S, M> | undefined,\n): AnyExtension<S, M, C> {\n  const policy =\n    declared === undefined\n      ? ({ strategy: \"stop\" } as const)\n      : typeof declared === \"string\"\n        ? ({ strategy: declared } as const)\n        : declared;\n  return (loop) => ({\n    update: (next) => (state, msg) => {\n      try {\n        return next(state, msg);\n      } catch (reduceError) {\n        loop.report(reduceError, \"reduce\");\n        switch (policy.strategy) {\n          case \"restart\":\n            // A throw inside `rehydrate` is NOT caught — it reaches the caller.\n            return [policy.rehydrate(state, msg, reduceError), []];\n          case \"escalate\":\n            throw reduceError;\n          default:\n            loop.halt();\n            throw reduceError;\n        }\n      }\n    },\n  });\n}\n\n/**\n * The instance-identity filter: drop a Msg addressed to a DIFFERENT instance\n * than the one this State owns, before the reducer sees it. A Msg with no\n * identity, or a State that has none yet, always proceeds. The drop is no\n * transition, and it RESOLVES the dispatch — a mis-addressed Msg is not the\n * caller's error — so it is reported as an `IdentityDropNotice` (warn by\n * default) or the caller could not tell \"applied\" from \"discarded\".\n *\n * Sits INSIDE {@link supervision}, so a throwing `ofMsg` / `ofState` is reported\n * and supervised exactly like a reducer throw (spike #264 run 3).\n */\nexport function identityFilter<S, M extends { type: string }, C>(\n  identity: Identity<S, M> | undefined,\n): AnyExtension<S, M, C> {\n  return (loop) => {\n    if (identity === undefined) return {};\n    const misaddressed = (msg: M, state: S): boolean => {\n      const addressed = identity.ofMsg(msg);\n      if (addressed === undefined) return false;\n      const own = identity.ofState(state);\n      if (own === undefined) return false;\n      return structuralHash(addressed) !== structuralHash(own);\n    };\n    return {\n      update: (next) => (state, msg) => {\n        if (!misaddressed(msg, state)) return next(state, msg);\n        loop.report(new IdentityDropNotice(msg.type), \"identity-drop\");\n        return null;\n      },\n    };\n  };\n}\n\n/**\n * The dev pre/post pair around the reducer (`checkedStep`): freeze the input\n * State so an in-place mutation trips, and check the returned `[state, cmds]`\n * shape. Both compile out of production. Innermost, so it sees exactly what the\n * reducer saw.\n */\nexport function devChecks<S, M extends { type: string }, C>(): AnyExtension<\n  S,\n  M,\n  C\n> {\n  return () => ({\n    update: (next) => (state, msg) => checkedStep(state, msg, next),\n  });\n}\n\n// === interpret middleware ===\n\n/**\n * The `Cmd.define` edge (ADR 0021): a defined Cmd's handler return is minted\n * into its `_ok` / `_err` Msg, its `ok` value parsed against the def's schema\n * and stamped with `at` from `clock`. A defined Cmd's handler failing outside\n * its declared channel goes to the sink under `\"interpret\"`; a hand-written\n * Cmd's handler throw keeps rejecting the dispatch.\n *\n * The same edge rides on ctx under `cmdEdge`, beside the `ok` / `err` builders,\n * so a handler that runs a base handler inside its own settles the base's\n * outcome through this one edge (#66).\n */\nexport function cmdDefinitions<S, M extends { type: string }, C>(\n  defs: readonly AnyCmdDef[],\n  clock: () => number,\n): AnyExtension<S, M, C> {\n  return (loop) => {\n    const settle = cmdEdgeOver(defs, clock);\n    const defined = new Set(defs.map((d) => d.cmdType));\n    return {\n      interpret: (next) => async (cmd) => {\n        const type = (cmd as { type: string }).type;\n        try {\n          return settle(cmd as { type: string }, await next(cmd));\n        } catch (err) {\n          if (!defined.has(type)) throw err;\n          loop.report(err, \"interpret\");\n          return undefined;\n        }\n      },\n      ctx: { ok: Outcome.ok, err: Outcome.err, [cmdEdge]: settle },\n    };\n  };\n}\n\n// === store wrapper ===\n\n/**\n * Fencing is a property of the store the caller handed `run`, never a flag\n * (#143). A fenced store is read with its version at boot and every save is a\n * compare-and-swap against the last version this run saw, so a second writer\n * that took over is refused with `StoreConflictError` at this run's next save —\n * before that transition's Cmds run. A plain store passes through unchanged.\n */\nexport function fencing<S, M, C>(): AnyExtension<S, M, C> {\n  return () => ({\n    store: (store: Store<S>): Store<S> => {\n      if (!isFencedStore(store)) return store;\n      let version = 0;\n      return {\n        async load() {\n          const read = await store.loadFenced();\n          version = read.version;\n          return read.raw;\n        },\n        async save(state) {\n          version = await store.saveFenced(state, version);\n        },\n        migrate: (raw) => store.migrate(raw),\n      };\n    },\n  });\n}\n\n// === ctx + handle: ports ===\n\n/**\n * Ports (`definePort`): `ctx.emit(port, value)` from a handler and\n * `emitPort` / `subscribePort` on the handle. Fanout is synchronous and\n * throw-isolated under `\"port-emit\"`; no subscribers is a no-op.\n */\nexport function ports<S, M, C>(): AnyExtension<S, M, C> {\n  return (loop) => {\n    const registry = new Map<Port<unknown>, Set<(value: unknown) => void>>();\n    function emit<T>(port: Port<T>, value: T): void {\n      const subscribers = registry.get(port as Port<unknown>);\n      if (!subscribers || subscribers.size === 0) return;\n      loop.fanout(subscribers, \"port-emit\", (listener) => listener(value));\n    }\n    return {\n      ctx: { emit },\n      handle: {\n        subscribePort<T>(\n          port: Port<T>,\n          listener: (value: T) => void,\n        ): () => void {\n          const key = port as Port<unknown>;\n          const bucket = registry.get(key) ?? new Set();\n          registry.set(key, bucket);\n          const erased = listener as (value: unknown) => void;\n          bucket.add(erased);\n          return () => {\n            bucket.delete(erased);\n            if (bucket.size === 0 && registry.get(key) === bucket)\n              registry.delete(key);\n          };\n        },\n        emitPort: emit,\n      },\n    };\n  };\n}\n\n// === commit observers ===\n\n/**\n * `subscribe` (zero-arg change notifiers), then `observe` (every applied\n * transition's `(msg, state)`) or, at boot, `onBoot` (the initial State, once;\n * a handler registered after boot fires at once). Each fanout is\n * throw-isolated under its own phase.\n */\nexport function observation<S, M, C>(): AnyExtension<S, M, C> {\n  return (loop) => {\n    const listeners = new Set<() => void>();\n    const observers = new Set<(msg: M, state: S) => void>();\n    const bootHandlers = new Set<(state: S) => void>();\n    let booted = false;\n    return {\n      commit(msg, state) {\n        loop.fanout(listeners, \"listener\", (listener) => listener());\n        if (msg === undefined) {\n          booted = true;\n          loop.fanout(bootHandlers, \"boot\", (handler) => handler(state));\n          return;\n        }\n        loop.fanout(observers, \"observer\", (observer) => observer(msg, state));\n      },\n      handle: {\n        subscribe: subscribeTo(listeners),\n        observe: subscribeTo(observers),\n        onBoot(handler: (state: S) => void): () => void {\n          const state = loop.state();\n          if (booted && state !== undefined) {\n            loop.fanout([handler], \"boot\", (h) => h(state));\n            return () => {};\n          }\n          return subscribeTo(bootHandlers)(handler);\n        },\n      },\n    };\n  };\n}\n\nfunction subscribeTo<T>(set: Set<T>): (item: T) => () => void {\n  return (item) => {\n    set.add(item);\n    return () => {\n      set.delete(item);\n    };\n  };\n}\n\n/**\n * The semantic event channel: `project` maps each APPLIED transition to zero or\n * more public events, and `on(type, handler)` receives only its own type. The\n * machine's private Msg names never reach `on`. A throw in the projector or a\n * handler is isolated under `\"event\"`. Boot projects nothing.\n */\nexport function semanticEvents<S, M, C, E extends { type: string }>(\n  project: ((msg: M, state: S) => readonly E[]) | undefined,\n): AnyExtension<S, M, C> {\n  return (loop) => {\n    const handlers = new Map<string, Set<(event: E) => void>>();\n    return {\n      commit(msg, state) {\n        if (msg === undefined || project === undefined || handlers.size === 0)\n          return;\n        let events: readonly E[];\n        try {\n          events = project(msg, state);\n        } catch (err) {\n          loop.report(err, \"event\");\n          return;\n        }\n        for (const event of events) {\n          const bucket = handlers.get(event.type);\n          if (bucket === undefined) continue;\n          loop.fanout(bucket, \"event\", (handler) => handler(event));\n        }\n      },\n      handle: {\n        on(type: string, handler: (event: E) => void): () => void {\n          const bucket = handlers.get(type) ?? new Set();\n          handlers.set(type, bucket);\n          bucket.add(handler);\n          return () => {\n            bucket.delete(handler);\n            if (bucket.size === 0 && handlers.get(type) === bucket)\n              handlers.delete(type);\n          };\n        },\n      },\n    };\n  };\n}\n\n/**\n * Run terminality: `result()` reads the State when `isTerminal` holds for it,\n * and `done()` resolves on the first commit (boot included — a rehydrated run\n * can land terminal) where it does. No predicate → never terminal.\n */\nexport function terminality<S, M, C>(\n  isTerminal: ((state: S) => boolean) | undefined,\n): AnyExtension<S, M, C> {\n  const holds = isTerminal ?? (() => false);\n  return (loop) => {\n    const waiters = new Set<(state: S) => void>();\n    return {\n      commit(_msg, state) {\n        if (waiters.size === 0 || !holds(state)) return;\n        const parked = [...waiters];\n        waiters.clear();\n        for (const resolve of parked) resolve(state);\n      },\n      handle: {\n        result(): S | undefined {\n          const current = loop.state() as S;\n          return holds(current) ? current : undefined;\n        },\n        done(): Promise<S> {\n          const current = loop.state() as S;\n          if (holds(current)) return Promise.resolve(current);\n          return new Promise<S>((resolve) => {\n            waiters.add(resolve);\n          });\n        },\n      },\n    };\n  };\n}\n\n/**\n * Telemetry (#268: `withTelemetry` moved inside tea). Every applied transition\n * hands the sink `{ seq, msgType, at }` — `seq` counts this run's applied\n * transitions from 1, `at` reads `clock`. Fire-and-forget: the loop never waits\n * on the sink, and a sink that throws or rejects reaches `onError` under\n * `\"observer\"` without touching the run.\n */\nexport function telemetry<S, M extends { type: string }, C>(\n  sink: TelemetrySink | undefined,\n  clock: () => number,\n): AnyExtension<S, M, C> {\n  return (loop: LoopServices<S>): Extension<S, M, C> => {\n    if (sink === undefined) return {};\n    let seq = 0;\n    return {\n      commit(msg) {\n        if (msg === undefined) return;\n        seq += 1;\n        const event: TelemetryEvent = { seq, msgType: msg.type, at: clock() };\n        try {\n          Promise.resolve(sink(event)).catch((err: unknown) =>\n            loop.report(err, \"observer\"),\n          );\n        } catch (err) {\n          loop.report(err, \"observer\");\n        }\n      },\n    };\n  };\n}\n\n// === assembly: the one order both engines run the built-ins in ===\n\n/** The `run` options the built-ins read. Every engine's `run` accepts them. */\nexport interface BuiltinOptions<\n  S,\n  M extends { type: string },\n  E extends { type: string },\n> {\n  readonly clock?: () => number;\n  readonly events?: (msg: M, state: S) => readonly E[];\n  readonly supervision?: Supervision<S, M>;\n  readonly terminal?: (state: S) => boolean;\n  readonly telemetry?: TelemetrySink;\n}\n\n/**\n * The built-ins, in the one order that gives them their meaning. Every engine\n * builds its loop from this list, so a machine means the same thing on each.\n *\n * Update middleware nests first-outermost: supervision wraps the identity\n * filter (a throwing `ofMsg` is supervised like a reducer throw — spike #264\n * run 3), which wraps the dev checks around the reducer itself. Commit\n * callbacks run in order: change listeners, then `observe` / `onBoot`, then\n * semantic events, then `done()` waiters, then telemetry.\n */\nexport function builtinExtensions<\n  S,\n  M extends { type: string },\n  C,\n  E extends { type: string },\n>(\n  machine: {\n    readonly identity?: Identity<S, M>;\n    readonly cmds?: readonly AnyCmdDef[];\n  },\n  opts: BuiltinOptions<S, M, E>,\n): readonly ExtensionFactory<S, M, C>[] {\n  const clock = opts.clock ?? Date.now;\n  return [\n    supervision(opts.supervision),\n    identityFilter(machine.identity),\n    devChecks(),\n    cmdDefinitions(machine.cmds ?? [], clock),\n    fencing(),\n    ports(),\n    observation(),\n    semanticEvents(opts.events),\n    terminality(opts.terminal),\n    telemetry(opts.telemetry, clock),\n  ];\n}\n","/**\n * The core loop both engines run (#280, spike #264). It does five things and\n * nothing else: it keeps one serial tail, folds a Msg into a transition, saves\n * before any effect, reconciles the running Subs, and runs the transition's\n * Cmds, dispatching what they return. It has no special case for any built-in.\n *\n * One loop, not one per engine (#283). The loop calls a handler and a runner\n * through erased signatures and awaits a Promise either way, so an engine's\n * own types never pass through it. The Effect engine turns each handler and\n * runner into a fiber at its own edge, run with the services the caller\n * provided, so Effect services (`R`) reach every handler without the loop\n * carrying a type slot for them — the gap spike #260's generic loop left open.\n * Sharing the loop is also what makes the two engines' traces identical: the\n * fold, the save order and the built-ins are the same code.\n *\n * Everything else `run` offers is an {@link Extension} built on five points:\n *\n *   1. `update`    — middleware over the fold. Returning `null` means \"no\n *                    transition\": no save, no effects, no commit.\n *   2. `interpret` — middleware over one Cmd's handler call; it maps what the\n *                    handler returned to the Msg to dispatch, if any.\n *   3. `store`     — a wrapper over the store the caller handed `run`.\n *   4. `commit`    — called after a transition's effects, with the Msg and the\n *                    committed State. Boot passes `undefined` for the Msg.\n *   5. `ctx`       — keys added to the ctx every Cmd handler receives, so a\n *                    handler that runs another handler inside its own can reach\n *                    the same machinery the loop applies to it.\n *\n * An extension may also add methods to the run handle (`handle`). Array order\n * is nesting order: the first extension's middleware is the outermost, and\n * commit callbacks run first to last. `builtinExtensions` (`./builtins`) fixes\n * that order for every engine; it is not a user-facing plugin API (#268).\n *\n * `stop()` is the core's own lifecycle, because the gate it drives is what every\n * dispatch passes through: open → draining → closed, never backwards.\n */\n\nimport type { Dispose, Sub, SubEntry } from \"../../pure/core\";\nimport { desiredSub, detachWork } from \"../../pure/core\";\nimport type {\n  DispatchSettle,\n  OnError,\n  RuntimeErrorContext,\n  RuntimeErrorPhase,\n  Store,\n} from \"../../runtime-types\";\nimport {\n  DispatchDiscardedError,\n  DisposeTimeoutNotice,\n  QuiescenceTimeoutError,\n  RuntimeDiscardedError,\n  RuntimeDiscardNotice,\n} from \"../../runtime-types\";\n\n// === The extension points ===\n\n/** A fold's result: the next State and the Cmds it emits. */\nexport type Transition<S, C> = readonly [S, readonly C[]];\n\n/** One fold step. `null` means the Msg produced no transition. */\nexport type Step<S, M, C> = (state: S, msg: M) => Transition<S, C> | null;\n\n/** One Cmd's handler call; resolves to the Msg to dispatch, or nothing. */\nexport type InterpretStep<C> = (cmd: C) => Promise<unknown>;\n\n/** What the loop lends an extension. */\nexport interface LoopServices<S> {\n  /** Route a failure with no caller to the `onError` sink. */\n  report(error: unknown, phase: RuntimeErrorPhase): void;\n  /** Call `fn` for each item, routing every throw to the sink under `phase`. */\n  fanout<T>(\n    items: Iterable<T>,\n    phase: RuntimeErrorPhase,\n    fn: (item: T) => void,\n  ): void;\n  /** Close the gate for good: every later dispatch is refused. */\n  halt(): void;\n  /** The committed State, or `undefined` before boot has produced one. */\n  state(): S | undefined;\n}\n\n/** One built-in, as the loop sees it. Every member is optional. */\nexport interface Extension<S, M, C> {\n  readonly update?: (next: Step<S, M, C>) => Step<S, M, C>;\n  readonly interpret?: (next: InterpretStep<C>) => InterpretStep<C>;\n  readonly store?: (store: Store<S>) => Store<S>;\n  readonly commit?: (msg: M | undefined, state: S) => void;\n  readonly ctx?: object;\n  readonly handle?: object;\n}\n\n/** An extension is built once per run, from the loop's services. */\nexport type ExtensionFactory<S, M, C> = (\n  loop: LoopServices<S>,\n) => Extension<S, M, C>;\n\n/** A Cmd handler as the loop calls it. */\nexport type LoopHandler<M> = (\n  cmd: never,\n  ctx: unknown,\n  dispatch: (msg: M) => void,\n) => unknown;\n\n/** A Sub runner as the loop calls it. */\nexport type LoopRunner<Ctx, M> = (\n  sub: Sub,\n  ctx: Ctx,\n  dispatch: (msg: M) => void,\n) => Dispose;\n\n/** Everything the loop needs from `run`. */\nexport interface LoopConfig<S, M extends { type: string }, C, Ctx> {\n  readonly init: (loaded: S | null, ctx: Ctx) => Transition<S, C>;\n  /** The innermost fold: the machine's own `update`. */\n  readonly reduce: (state: S, msg: M) => Transition<S, C>;\n  readonly subs: readonly SubEntry<S>[];\n  readonly runnerFor: (type: string) => LoopRunner<Ctx, M> | undefined;\n  readonly handlerFor: (type: string) => LoopHandler<M> | undefined;\n  readonly store: Store<S> | undefined;\n  readonly ctx: Ctx;\n  readonly onError: OnError | undefined;\n  readonly disposeTimeoutMs: number;\n  readonly idleCap: number;\n  readonly extensions: readonly ExtensionFactory<S, M, C>[];\n}\n\n// === liveWork: \"can anything still transition me without a dispatch?\" ===\n//\n// The one read `driveToDone` needs that the public `Runtime` does not carry:\n// after `start`'s chain quiesces, only a live Sub or an in-flight Cmd can still\n// enqueue a transition; with neither, waiting is a leak (#68). Module-private\n// and symbol-keyed so it reaches no export (the export map is the contract —\n// MAINTAINING.md), yet enumerable so it survives the spread a wrapper does over\n// the handle.\nexport const liveWork: unique symbol = Symbol(\"demlik-tea.liveWork\");\n\n/** The runtime's own sources of a caller-less transition, counted. */\nexport interface LiveWork {\n  /** Live Subs — the running `machine.subs` entries. */\n  readonly subs: number;\n  /** Interpret handlers currently awaiting. */\n  readonly cmds: number;\n}\n\nexport interface LiveWorkProbe {\n  readonly [liveWork]: () => LiveWork;\n}\n\n/** The members the core itself puts on the run handle. */\nexport interface LoopHandle<S, M> extends LiveWorkProbe {\n  dispatch(msg: M, opts?: { readonly settle?: DispatchSettle }): Promise<void>;\n  dispatchOnce(msg: M): Promise<void>;\n  getState(): S;\n  ready: Promise<unknown>;\n  idle(): Promise<void>;\n  stop(): Promise<void>;\n}\n\n// Default `onError` sink: re-throw on a fresh macrotask so the failure reaches\n// the host's global error handler instead of vanishing — surface, not swallow\n// (invariant 6).\n//\n// A `RuntimeDiscardNotice` is NOT a failure of the runtime's own contract — a\n// host tearing a runtime down with Cmds in flight (a React ctx change, a\n// navigation) is legal, merely lossy. Rethrowing it would make every\n// unmount-during-fetch an uncaught error for consumers who never configured a\n// sink, so the default WARNS: loud enough that the silent discard #365\n// describes cannot happen again, never fatal. A configured `onError` sees\n// `\"discard\"` like any other phase and can route or ignore it.\n//\n// The branch keys on the ERROR CLASS, never on `context.phase`: `report`\n// hands a THROWING consumer sink's own error back here with the phase it was\n// handling, so a phase-keyed branch would warn away a broken sink and re-create\n// the very silent failure this exists to remove.\nfunction defaultOnError(error: unknown, _context: RuntimeErrorContext): void {\n  if (error instanceof RuntimeDiscardNotice) {\n    console.warn(error);\n    return;\n  }\n  setTimeout(() => {\n    throw error;\n  }, 0);\n}\n\n/**\n * Start the loop. Returns the handle synchronously; boot runs as the FIRST entry\n * on the serial tail. Save-then-effects ordering is structural: every\n * transition installs State, awaits the save, reconciles Subs, runs the Cmds,\n * then calls the commit callbacks.\n */\nexport function startLoop<S, M extends { type: string }, C, Ctx>(\n  config: LoopConfig<S, M, C, Ctx>,\n): LoopHandle<S, M> {\n  const { idleCap, disposeTimeoutMs } = config;\n  const onError: OnError = config.onError ?? defaultOnError;\n\n  // A throwing sink routes THAT throw through `defaultOnError`, with the context\n  // the sink was handling, so it cannot re-create a silent failure.\n  function report(error: unknown, phase: RuntimeErrorPhase): void {\n    const context: RuntimeErrorContext = { phase };\n    try {\n      onError(error, context);\n    } catch (sinkError) {\n      defaultOnError(sinkError, context);\n    }\n  }\n\n  // Throw-isolated fanout: one bad consumer never strands its siblings\n  // (invariant 6). The single home for that isolation discipline.\n  function fanout<T>(\n    items: Iterable<T>,\n    phase: RuntimeErrorPhase,\n    fn: (item: T) => void,\n  ): void {\n    for (const item of items) {\n      try {\n        fn(item);\n      } catch (err) {\n        report(err, phase);\n      }\n    }\n  }\n\n  // `state` is late-initialized: synchronously when there is no store to read,\n  // otherwise inside the boot step (the head of the tail).\n  let state: S | undefined;\n  let bootError: unknown = null;\n  // The dispatch gate. It only ever ADVANCES — `\"open\"` → `\"draining\"` →\n  // `\"closed\"` — so the discard window can never re-open under a second `stop()`.\n  //\n  //   \"open\"     — normal operation; `enqueueDispatch` accepts.\n  //   \"draining\" — inside `stop()`, before the tail has settled. New work is\n  //                still refused (refusing is what makes the drain terminate),\n  //                but a Msg refused HERE was discarded BY the teardown: an\n  //                in-flight Cmd's follow-up, a detached handler's last Msg, or a\n  //                Sub still live because subs are torn down after the drain. So\n  //                the rejection is a `DispatchDiscardedError` reported under\n  //                `phase: \"discard\"` — lossy, legal, warn-only.\n  //   \"closed\"   — halted by an extension, or `stop()` has returned. A dispatch\n  //                refused here is a consumer using a retired runtime — a real\n  //                error, and it stays loud.\n  let gate: \"open\" | \"draining\" | \"closed\" = \"open\";\n  // Interpret handlers currently awaiting. Written only by `trackInFlight`, read\n  // by `stop()` to make a mid-flight teardown LOUD instead of silent (#365).\n  let inFlightCmds = 0;\n\n  const services: LoopServices<S> = {\n    report,\n    fanout,\n    halt() {\n      gate = \"closed\";\n    },\n    state: () => state,\n  };\n  const extensions = config.extensions.map((make) => make(services));\n\n  // The fold, the handler call and the store, each wrapped by the extensions\n  // that ask for it. `reduceRight` makes the first extension the outermost.\n  const update: Step<S, M, C> = extensions.reduceRight<Step<S, M, C>>(\n    (next, ext) => (ext.update ? ext.update(next) : next),\n    config.reduce,\n  );\n  const interpret: InterpretStep<C> = extensions.reduceRight<InterpretStep<C>>(\n    (next, ext) => (ext.interpret ? ext.interpret(next) : next),\n    callHandler,\n  );\n  const store: Store<S> | undefined =\n    config.store === undefined\n      ? undefined\n      : extensions.reduceRight<Store<S>>(\n          (inner, ext) => (ext.store ? ext.store(inner) : inner),\n          config.store,\n        );\n  const commitCallbacks = extensions.flatMap((ext) =>\n    ext.commit ? [ext.commit] : [],\n  );\n\n  // Copied into a fresh object so handlers get the contributed keys without\n  // mutating the caller's ctx (which may be shared across runtimes / tests).\n  // `Object.assign`, not a spread: tsc cannot prove a generic `Ctx` is an\n  // object type, and a spread refuses it.\n  const handlerCtx: unknown = Object.assign(\n    {},\n    config.ctx,\n    ...extensions.map((ext) => ext.ctx ?? {}),\n    { [detachWork]: detachInFlight },\n  );\n\n  // Every step chains onto `tail` — the single concurrency gate.\n  let tail: Promise<void> = Promise.resolve();\n\n  // The running Subs, keyed by their derived id. An id present here is a runner\n  // that started and has not been disposed.\n  const subRegistry = new Map<string, { type: string; dispose: Dispose }>();\n\n  // Tear down each named sub: run its cleanup (throws routed to the sink under\n  // `\"sub-cleanup\"`), then drop it from the registry regardless.\n  function stopSubs(ids: Iterable<string>): void {\n    for (const id of ids) {\n      const running = subRegistry.get(id);\n      if (running === undefined) continue;\n      try {\n        trackDisposal(running.dispose());\n      } catch (err) {\n        report(err, \"sub-cleanup\");\n      }\n      subRegistry.delete(id);\n    }\n  }\n\n  // Teardown work that returned a Promise and has not settled. Reconcile runs\n  // inside the synchronous transition path (invariant 2) and cannot await a\n  // cleanup, so every async disposal is remembered here the moment it starts,\n  // and `stop()` drains the set before resolving: `await runtime.stop()` then\n  // means \"teardown is done\", the only reading a host evicting an isolate can\n  // act on. The rejection is attached HERE, once, so it can never become an\n  // unhandled rejection.\n  const pendingDisposals = new Set<Promise<void>>();\n\n  function trackDisposal(result: void | Promise<void>): void {\n    if (!(result instanceof Promise)) return;\n    const settling: Promise<void> = result\n      .catch((err) => {\n        report(err, \"sub-cleanup\");\n      })\n      .finally(() => {\n        pendingDisposals.delete(settling);\n      });\n    pendingDisposals.add(settling);\n  }\n\n  /**\n   * Wait for the disposals started so far, bounded by `disposeTimeoutMs`. On\n   * expiry report a `DisposeTimeoutNotice` and return anyway — `stop()` resolves\n   * regardless (contract), and a release that never settles must not become a\n   * host that never shuts down.\n   */\n  async function drainDisposals(): Promise<void> {\n    if (pendingDisposals.size === 0) return;\n    const outstanding = [...pendingDisposals];\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    try {\n      const outcome = await Promise.race([\n        Promise.all(outstanding).then(() => \"settled\" as const),\n        new Promise<\"timeout\">((resolve) => {\n          timer = setTimeout(() => resolve(\"timeout\"), disposeTimeoutMs);\n        }),\n      ]);\n      if (outcome === \"timeout\") {\n        report(\n          new DisposeTimeoutNotice(outstanding.length, disposeTimeoutMs),\n          \"discard\",\n        );\n      }\n    } finally {\n      if (timer !== undefined) clearTimeout(timer);\n    }\n  }\n\n  /**\n   * Reconcile the running Subs against `state`, after every save. An id already\n   * running is left alone, a running id no longer wanted is stopped, and a\n   * wanted id not yet running is started through its runner.\n   *\n   * Every failure is collected, never thrown mid-pass, so one bad entry cannot\n   * strand its siblings: a throwing `deps` leaves the running Subs of that type\n   * untouched, and a throwing runner is not registered. The first error is\n   * thrown after the pass. A Sub type with no runner is a failure too — nothing\n   * would ever start it.\n   */\n  function reconcileSubs(): void {\n    let firstError: unknown = null;\n    const remember = (err: unknown): void => {\n      if (firstError === null) firstError = err;\n    };\n    const desired = new Map<string, Sub>();\n    // Types whose entry could not be read this pass: keep what is running.\n    const unreadTypes = new Set<string>();\n    for (const entry of config.subs) {\n      try {\n        const sub = desiredSub(entry, state as S);\n        if (sub !== null) desired.set(sub.id, sub);\n      } catch (err) {\n        remember(err);\n        unreadTypes.add(entry.type);\n      }\n    }\n\n    stopSubs(\n      [...subRegistry].flatMap(([id, running]) =>\n        desired.has(id) || unreadTypes.has(running.type) ? [] : [id],\n      ),\n    );\n\n    for (const [id, sub] of desired) {\n      if (subRegistry.has(id)) continue;\n      const runner = config.runnerFor(sub.type);\n      if (runner === undefined) {\n        remember(\n          new Error(\n            `@demlik/tea: no subscribe runner for Sub type \"${sub.type}\". ` +\n              \"Pass one to run in `subscribe`.\",\n          ),\n        );\n        continue;\n      }\n      try {\n        // A runner's dispatch is unawaited by construction, so it gets the\n        // wrapped form, which also queues the transition behind this step —\n        // never on the runner's own stack (spike #260).\n        const dispose = runner(sub, config.ctx, dispatchUnawaited);\n        subRegistry.set(id, { type: sub.type, dispose });\n      } catch (err) {\n        remember(err);\n      }\n    }\n    if (firstError !== null) throw firstError;\n  }\n\n  // The ONE `(msg) => void` handed to every producer that cannot await its own\n  // dispatch: a Cmd handler's late tail, a Sub runner. Its rejection has no\n  // caller, so it routes to the sink with the phase derived from the error\n  // class (`reportUndelivered`). Handing those sites the raw `enqueueDispatch`\n  // would turn a Sub firing during `stop()`'s drain into an unhandled rejection\n  // the sink never sees.\n  function dispatchUnawaited(msg: M): void {\n    enqueueDispatch(msg).catch(reportUndelivered);\n  }\n\n  // A `DispatchDiscardedError` means the teardown refused the Msg (`\"discard\"`,\n  // warn-only); anything else is a genuine failure of the follow-up itself.\n  function reportUndelivered(error: unknown): void {\n    report(\n      error,\n      error instanceof DispatchDiscardedError ? \"discard\" : \"follow-up\",\n    );\n  }\n\n  /**\n   * Count a handler's work as in flight for exactly the lifetime of its\n   * promise. `finally`-balanced, so a rejecting handler can never strand the\n   * count above zero. A handler that throws SYNCHRONOUSLY never reaches here,\n   * which is correct — it was never in flight.\n   */\n  function trackInFlight<T>(work: T | Promise<T>): Promise<T> {\n    inFlightCmds++;\n    return Promise.resolve(work).finally(() => {\n      inFlightCmds--;\n    });\n  }\n\n  /**\n   * Enlist work a handler will NOT return — the `detachWork` key on ctx. A\n   * handler that fans out inside its own Cmd (ADR 0018) returns before its\n   * effect finishes; handing the promise here puts it back on both accountings\n   * a returned promise had: `trackInFlight`, so `stop()` still reports it, and\n   * the serial `tail`, so `idle()` drains it. The tail extension is\n   * SYNCHRONOUS, so a `drainToQuiescence` that already read `tail` sees the\n   * reference change and loops again.\n   */\n  function detachInFlight(work: Promise<unknown>): void {\n    const tracked = trackInFlight(work);\n    tracked.catch(reportUndelivered);\n    tail = tail\n      .then(async () => {\n        await tracked;\n      })\n      .catch(() => {});\n  }\n\n  // The innermost interpret step: call the Cmd's handler, if one is wired. A\n  // missing handler returns nothing, which is invariant 6's forward progress\n  // for a miswired consumer.\n  function callHandler(cmd: C): Promise<unknown> {\n    const handler = config.handlerFor((cmd as { type: string }).type);\n    if (handler === undefined) return Promise.resolve(undefined);\n    return trackInFlight(handler(cmd as never, handlerCtx, dispatchUnawaited));\n  }\n\n  /**\n   * Run each emitted Cmd. A returned Msg is enqueued onto the tail, never\n   * dispatched re-entrantly. The first error stops further handlers in this\n   * transition.\n   *\n   * THIS LOOP IS SERIAL BY RULING, NOT BY OVERSIGHT (ADR 0018). It runs a\n   * transition's Cmds one at a time and never interleaves two handlers, so the\n   * Msgs it enqueues fold in Cmd-EMISSION order and a replayed log reproduces\n   * the same fold — invariant 2's serializability. Overlap in time belongs\n   * INSIDE one Cmd's handler, never across the Cmds of one transition.\n   */\n  async function runCmds(cmds: readonly C[]): Promise<void> {\n    for (const cmd of cmds) {\n      const follow = await interpret(cmd);\n      if (follow !== undefined && follow !== null) {\n        enqueueDispatch(follow as M).catch(reportUndelivered);\n      }\n    }\n  }\n\n  // Install State, then save → reconcile subs → run Cmds → commit callbacks.\n  // Save-before-effects is the hard ordering; tests pin it. Boot and every\n  // transition end here; boot passes no Msg.\n  async function commit(\n    next: S,\n    msg: M | undefined,\n    cmds: readonly C[],\n  ): Promise<void> {\n    state = next;\n    if (store) await store.save(next);\n    reconcileSubs();\n    await runCmds(cmds);\n    for (const callback of commitCallbacks) callback(msg, next);\n  }\n\n  // One full transition. A `null` from the fold is no transition at all, and\n  // it RESOLVES the dispatch. A throw from the fold rejects it.\n  async function stepDispatch(msg: M): Promise<void> {\n    if (state === undefined) {\n      throw new Error(\"@demlik/tea: runtime not booted\");\n    }\n    const transition = update(state, msg);\n    if (transition === null) return;\n    await commit(transition[0], msg, transition[1]);\n  }\n\n  // With NO store there is nothing to read, so `init` runs IMMEDIATELY and\n  // `getState()` is observable synchronously (what `useSyncExternalStore`\n  // consumers need to render the first commit without a flicker); an `init`\n  // throw leaves `run` itself. With a store, the read is the first thing boot\n  // awaits; a `load` or `migrate` throw rejects `ready`.\n  const storeless: Transition<S, C> | null =\n    store === undefined ? config.init(null, config.ctx) : null;\n  if (storeless !== null) state = storeless[0];\n\n  async function boot(): Promise<void> {\n    // Boundary parse (invariant 8): `store.load()` returns `unknown`;\n    // `store.migrate(raw)` is the required parse — `S` on a recognized shape,\n    // `null` on an unrecognized one (boots fresh).\n    const [initial, cmds] =\n      storeless ??\n      config.init(\n        (store as Store<S>).migrate(await (store as Store<S>).load()),\n        config.ctx,\n      );\n    await commit(initial, undefined, cmds);\n  }\n\n  /**\n   * Enqueue a dispatch on the tail — the single gate re-entrant handler and\n   * runner calls also go through. Rejects when the gate is not open (with a\n   * `DispatchDiscardedError` while `stop()` drains, a plain stopped Error once\n   * it has), boot failed, or the fold / save / sub start / handler throws.\n   */\n  function enqueueDispatch(msg: M): Promise<void> {\n    if (gate !== \"open\") {\n      return Promise.reject(\n        gate === \"draining\"\n          ? new DispatchDiscardedError(msg.type)\n          : new Error(\"@demlik/tea: runtime stopped\"),\n      );\n    }\n    const next = tail.then(() => {\n      if (bootError !== null) throw bootError;\n      return stepDispatch(msg);\n    });\n    // Swallow the rejection on the tail so one failing dispatch does NOT poison\n    // every later one. The original `next` still rejects for the caller.\n    tail = next.catch(() => {});\n    return next;\n  }\n\n  /**\n   * Drain the serial tail to quiescence. Every follow-up reassigns `tail`\n   * SYNCHRONOUSLY before its parent step resolves, so awaiting the current\n   * `tail` and re-reading it catches every transitively enqueued follow-up.\n   * Bounded by `idleCap` — on cap REJECT with `QuiescenceTimeoutError`, keeping\n   * a livelock distinguishable from quiescence (invariant 6).\n   */\n  async function drainToQuiescence(): Promise<void> {\n    for (let i = 0; i < idleCap; i++) {\n      const observed = tail;\n      await observed;\n      if (tail === observed) return;\n    }\n    throw new QuiescenceTimeoutError(idleCap);\n  }\n\n  /**\n   * The public `dispatch`: await the Msg's OWN transition first (so its own\n   * failure surfaces before any drain), then — unless `{ settle: \"once\" }` —\n   * drain the transitive follow-up chain.\n   */\n  async function dispatchToQuiescence(\n    msg: M,\n    opts?: { readonly settle?: DispatchSettle },\n  ): Promise<void> {\n    await enqueueDispatch(msg);\n    if (opts?.settle === \"once\") return;\n    await drainToQuiescence();\n  }\n\n  // `bootPromise` is the un-swallowed promise `ready` chains off (so callers\n  // see the boot error directly); `tail` gets the swallowed branch so a failed\n  // boot does not poison every later dispatch's chain (each surfaces\n  // `bootError` in `enqueueDispatch`).\n  const bootPromise = boot();\n  tail = bootPromise.catch((err) => {\n    bootError = err;\n  });\n\n  const core: LoopHandle<S, M> = {\n    [liveWork]: () => ({ subs: subRegistry.size, cmds: inFlightCmds }),\n    dispatch: dispatchToQuiescence,\n    dispatchOnce: enqueueDispatch,\n    getState(): S {\n      // TOTAL. A booted handle is only obtainable by awaiting `ready`, which\n      // resolves AFTER boot set `state`.\n      return state as S;\n    },\n    // A failed boot never hands out a handle. The forward reference resolves\n    // at `.then` time, after `handle` below is built.\n    ready: bootPromise.then(() => handle),\n    idle: drainToQuiescence,\n    async stop(): Promise<void> {\n      // Open the discard window unless the gate is already `\"closed\"` (a halt,\n      // or a redundant second `stop()`): the gate only advances.\n      if (gate === \"open\") gate = \"draining\";\n      // Report BEFORE the drain: after `await tail` the count is zero by\n      // construction, and the fact worth surfacing is what was outstanding at\n      // the moment the host let go (#365).\n      if (inFlightCmds > 0) {\n        report(new RuntimeDiscardedError(inFlightCmds), \"discard\");\n      }\n      // Drain in-flight work. Tail rejections were swallowed at enqueue time, so\n      // this always resolves. It TERMINATES because the gate refuses the\n      // follow-ups those handlers return.\n      await tail;\n      gate = \"closed\";\n      stopSubs([...subRegistry.keys()]);\n      // …then WAIT for the teardown still settling, bounded by\n      // `disposeTimeoutMs` (see `drainDisposals`).\n      await drainDisposals();\n      // Flush final State. A save throw does not reject `stop()` (contract:\n      // resolves regardless) but IS loss of the last write, so it reaches the\n      // sink (invariant 6).\n      if (store && state !== undefined && bootError === null) {\n        try {\n          await store.save(state);\n        } catch (error) {\n          report(error, \"stop-save\");\n        }\n      }\n    },\n  };\n  const handle: LoopHandle<S, M> = Object.assign(\n    core,\n    ...extensions.map((ext) => ext.handle ?? {}),\n  );\n  return handle;\n}\n"]}