@demlik/tea 0.12.0 → 0.14.0

package/dist/index-Bc40JWVl.d.ts

@@ -0,0 +1,131 @@
+/**
+ * internal/idempotency/idempotency — dedupe-by-key + last-result cache as pure state + ops.
+ *
+ * Same shape as `../../work-queue`'s `ops.ts` and `../../resilience/rate-limit`:
+ * a state type plus pure transition functions. Host-agnostic by construction —
+ * no `Date.now()`, no timers, no I/O. The caller injects the clock (`nowMs`)
+ * and wires the result into its own reducer / interpret. This keeps the store
+ * inside TEA's invariant 2 (transitions are pure: same inputs → same outputs,
+ * no `Date.now`) so a consumer can fold it through `update` and exercise it
+ * with `replay` / the pbt fold without a fake clock.
+ *
+ * Every op returns a NEW store value and never mutates its input (invariant 1 —
+ * state is a value, not a place). `seen` / `recall` are read-shaped predicates;
+ * `remember` / `evictExpired` return a new store.
+ *
+ * The use case: a webhook receiver, a retried queue message, or a repeated user
+ * action arrives carrying an idempotency key. `seen(store, key, now)` answers
+ * "did I already process this?"; `recall(store, key, now)` returns the cached
+ * result so the duplicate request gets the SAME response the original produced
+ * rather than re-running the side effect. `remember(store, key, value, now)`
+ * records the key + its result after the first run.
+ *
+ * Two eviction policies keep the store bounded, both injected at `initStore`:
+ *
+ *   - **`ttlMs`** — an entry expires `ttlMs` after the `atMs` it was remembered
+ *     at. `seen` / `recall` treat an expired entry as absent; `evictExpired`
+ *     (and every `remember`) physically drops it. Without a TTL, entries live
+ *     until evicted by capacity. The cutoff is half-open: an entry exactly
+ *     `ttlMs` old is expired (`age >= ttlMs` drops it), matching `rate-limit`'s
+ *     window edge — a key remembered at `t` no longer counts at `t + ttlMs`.
+ *   - **`capacity`** — at most `capacity` entries are retained. When a
+ *     `remember` would push the count past `capacity` (after expiry eviction),
+ *     the OLDEST entries by insertion `order` are dropped until the count fits.
+ *     Without a capacity, the store grows unbounded (TTL alone bounds it).
+ *
+ * `order` is the insertion-order index that capacity eviction reads — the keys
+ * oldest-first. It is the store's own LRU-by-insertion ledger, kept in lockstep
+ * with `entries` so `entries` never needs to be sorted to find the oldest.
+ *
+ * **Overwrite semantics** (decided + pinned by tests): re-`remember`ing an
+ * existing key is an UPDATE, not a no-op. It (1) overwrites `value`, (2)
+ * refreshes `atMs` to the new `nowMs` — so the TTL clock restarts and a
+ * frequently-seen key never expires — and (3) moves the key to the NEWEST
+ * position in `order` — so capacity eviction treats a re-remembered key as
+ * fresh, not as a stale candidate for eviction. This makes `remember` behave
+ * like "touch": a key actively being re-seen is kept alive on both the TTL and
+ * capacity axes.
+ *
+ * Internal since #47 — not published on any subpath; reached from inside the
+ * package as `internal/idempotency/idempotency`. Same one-shape-per-package rule
+ * as `work-queue`, `rate-limit`, and `do`.
+ */
+/**
+ * A cached entry: the result `value` the original request produced and the
+ * clock reading `atMs` it was remembered at. `atMs` is the TTL anchor — expiry
+ * is measured from here, and a re-`remember` refreshes it. Both fields are
+ * plain data so the whole store is trivially JSON-serializable into a
+ * consumer's `Store<S>`.
+ */
+interface IdempotencyEntry<V> {
+    readonly value: V;
+    readonly atMs: number;
+}
+/**
+ * The dedupe store: a map of `key → entry`, an insertion-`order` ledger
+ * (oldest-first) that capacity eviction reads, and the two optional bounds.
+ *
+ * `entries` and `order` are kept in lockstep — every key in `order` has an
+ * entry and vice versa. `capacity` / `ttlMs` are carried on the store (not
+ * passed per-op) so a single value fully describes the policy; a consumer
+ * persists the store and rehydrates the same bounds without re-deriving them.
+ */
+interface IdempotencyStore<V> {
+    readonly entries: Readonly<Record<string, IdempotencyEntry<V>>>;
+    readonly order: readonly string[];
+    readonly capacity?: number;
+    readonly ttlMs?: number;
+}
+/**
+ * Create an empty store. `capacity` and `ttlMs` are both optional — omit both
+ * for an unbounded cache, supply either or both to bound by count, age, or
+ * both. Stored on the returned value so every later op reads the policy off
+ * the store rather than from a re-passed argument.
+ */
+declare function initStore<V>(opts?: {
+    capacity?: number;
+    ttlMs?: number;
+}): IdempotencyStore<V>;
+/**
+ * True iff `key` is present AND not expired at `nowMs`. This is the dedupe
+ * predicate: a webhook / retried message / repeated action whose key returns
+ * `true` has already been processed and should be short-circuited (paired with
+ * `recall` to return the original result). PURE — reads only, never mutates.
+ */
+declare function seen<V>(store: IdempotencyStore<V>, key: string, nowMs: number): boolean;
+/**
+ * The cached `value` for `key` if present and unexpired at `nowMs`, else
+ * `undefined`. Use after `seen` returns `true` to replay the original result to
+ * a duplicate request. An expired entry reads as absent (returns `undefined`)
+ * even though it is physically still in `entries` until the next `remember` /
+ * `evictExpired` drops it. PURE — reads only, never mutates.
+ */
+declare function recall<V>(store: IdempotencyStore<V>, key: string, nowMs: number): V | undefined;
+/**
+ * Drop every entry expired at `nowMs` (older than `ttlMs`). Returns a NEW store
+ * with the survivors; `order` is rebuilt to drop the same keys, preserving the
+ * relative insertion order of the survivors. A no-TTL store returns an
+ * equivalent store (nothing ages out). PURE — the input store is never mutated.
+ */
+declare function evictExpired<V>(store: IdempotencyStore<V>, nowMs: number): IdempotencyStore<V>;
+/**
+ * Record `key → value` at `nowMs`, then enforce both bounds. PURE — returns a
+ * new store; the input is untouched.
+ *
+ * Order of operations (each step matters):
+ *   1. **Expiry eviction** — drop everything older than `ttlMs` first, so an
+ *      expired key never occupies a capacity slot the new entry could take, and
+ *      a stale entry under the same `key` is cleared before the overwrite.
+ *   2. **Insert / overwrite** — write the new entry. If `key` already exists,
+ *      this is an UPDATE: `value` is overwritten, `atMs` is refreshed to
+ *      `nowMs` (restarting the TTL clock), and the key is moved to the NEWEST
+ *      position in `order` (removed from wherever it sat, appended at the end).
+ *      See the module-level "Overwrite semantics" note.
+ *   3. **Capacity eviction** — if the entry count now exceeds `capacity`, drop
+ *      the OLDEST keys by `order` until the count fits. Because step 2 moves a
+ *      re-remembered key to the newest position, an actively re-seen key is
+ *      never the eviction victim.
+ */
+declare function remember<V>(store: IdempotencyStore<V>, key: string, value: V, nowMs: number): IdempotencyStore<V>;
+
+export { type IdempotencyStore as I, type IdempotencyEntry as a, remember as b, evictExpired as e, initStore as i, recall as r, seen as s };

package/dist/{debounce/index.d.ts → index-DHSUmQTR.d.ts}

@@ -1,15 +1,15 @@
 /**
- * @demlik/tea/debounce — a timer-based call transformer that coalesces a burst
+ * internal/timing/debounce — a timer-based call transformer that coalesces a burst
  * of calls into a single fire.
  *
- * Sibling of `@demlik/tea/throttle` — the two share a SYMMETRIC surface
+ * Sibling of `../throttle` — the two share a SYMMETRIC surface
  * (`Debounced<A>` / `Throttled<A>`, both callable + `.cancel()` + `.flush()`,
  * both `{ leading?, trailing? }`) so they read as a pair. They are kept in
  * separate files with NO cross-import: each is a self-contained timer, and the
  * coalesce-vs-drop policies are different enough that sharing code would hide
  * the distinction. Read one to understand the other; do not couple them.
  *
- * Layering with `@demlik/tea/throttled-input`: `debounce` and `throttle` are
+ * Layering with `../throttled-input`: `debounce` and `throttle` are
  * the two host-boundary PRIMITIVES — two distinct algorithms (collapse-a-burst
  * vs at-most-once-per-window) behind one signature shape. `throttled-input` is
  * NOT a third primitive: it is a TEA machine composed OVER them that
@@ -39,9 +39,9 @@
  *   window.addEventListener("resize", onResized);
  *   // cleanup: onResized.cancel(); window.removeEventListener("resize", onResized);
  *
- * NOT exported from the package root — reached via the `@demlik/tea/debounce`
- * subpath, same one-shape-per-package rule as `rate-limit`, `deadline`, and
- * `work-queue`.
+ * Internal since #47 — not published on any subpath; reached from inside the
+ * package as `internal/timing/debounce`. Same one-shape-per-package rule as
+ * `rate-limit`, `deadline`, and `work-queue`.
  *
  * Uses the universal `setTimeout` / `clearTimeout` timer idiom (same discipline
  * as `subs/from-timeout.ts`): exactly one live handle at a time, every arm
@@ -117,4 +117,4 @@ declare function debounce<A extends readonly unknown[]>(fn: (...args: A) => void
     trailing?: boolean;
 }): Debounced<A>;
 
-export { type Debounced, debounce };
+export { type Debounced as D, debounce as d };

package/dist/index-DJWIER_3.d.ts

@@ -0,0 +1,69 @@
+import { S as Store } from './runtime-types-LWDoi943.js';
+
+/**
+ * internal/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.
+ *
+ * Two public surfaces, one shape:
+ *   - `createQueue(store)` (this file) is the in-process adapter — it binds the
+ *     pure ops to an injected `Store` and runs `load → mutate → save`.
+ *   - `internal/work-queue/ops` (`./ops`) is the BLESSED, importable surface
+ *     of those same pure ops. L2 compositions that own their own Model slice
+ *     (`monitored-run`, `idempotent-intake`, …) import the ops directly and
+ *     delegate status flips to them instead of re-rolling the transitions.
+ * Both routes call the identical ops, so the lifecycle rules live in exactly
+ * one place. This mirrors `@demlik/tea/do`'s one-shape-per-package rule.
+ *
+ * The package is generic in the input payload `I` (audit-specific fields go
+ * here in the extension host). `output` is a free-form side-channel correlation
+ * token (a backend id, URL, trace id) — typed as `string` because that's its
+ * only honest type. Consumers that need structured per-item data persist it in
+ * their own store and put the foreign-key string in `output`.
+ */
+
+type QueueItemStatus = "pending" | "running" | "done" | "failed" | "cancelled";
+/**
+ * A single queue entry. Every field is `readonly`: a persisted slice is
+ * immutable, so a transition returns a NEW item (the ops always spread —
+ * `{ ...item, status: … }`) rather than mutating in place. This type-enforces
+ * the durability invariant the consumers already honor by convention, and
+ * keeps a slice round-trippable through JSON unchanged across a reload.
+ */
+interface QueueItem<I> {
+    readonly id: string;
+    readonly status: QueueItemStatus;
+    readonly input: I;
+    readonly enqueuedAt: number;
+    readonly startedAt?: number;
+    readonly finishedAt?: number;
+    readonly output?: string;
+    readonly error?: string;
+}
+/**
+ * Caller-facing enqueue payload. Just `I` today — kept named so future
+ * variants (priority, deferUntil, …) can grow without breaking callers.
+ */
+type EnqueueInput<I> = I;
+/**
+ * Adapter that binds the pure ops to an injected `Store<QueueItem<I>[]>`.
+ *
+ * `load → mutate → save` is the only durability discipline this package
+ * imposes. The store decides what "save" means (chrome.storage, KV, DO
+ * storage, in-memory) — that decision belongs at the caller.
+ *
+ * Ops that don't change the queue (e.g. `markDone` on an unknown id) skip the
+ * save call so the underlying store doesn't observe a write churn.
+ */
+declare function createQueue<I>(store: Store<QueueItem<I>[]>): {
+    enqueue: (input: EnqueueInput<I>) => Promise<QueueItem<I>>;
+    claimNext: () => Promise<QueueItem<I> | null>;
+    markDone: (id: string) => Promise<void>;
+    markFailed: (id: string, error: string) => Promise<void>;
+    markCancelled: (id: string) => Promise<void>;
+    resetRunningToPending: () => Promise<void>;
+    removeItem: (id: string) => Promise<void>;
+    retryItem: (id: string) => Promise<void>;
+    bindOutput: (id: string, value: string) => Promise<void>;
+    list: () => Promise<QueueItem<I>[]>;
+};
+
+export { type EnqueueInput as E, type QueueItem as Q, type QueueItemStatus as a, createQueue as c };

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

@@ -1,74 +1,4 @@
-import { C as Cmd, I as Interpret } from '../core-Bjc0bS8j.js';
-
-/**
- * @demlik/tea/snapshot — periodic state checkpoint to a host store (R2/KV-shaped).
- *
- * The problem it solves: a long-running machine (a multi-stage run, a paginated
- * crawl, a saga) lives in TEA's in-memory `State` and is persisted as ONE blob
- * by the substrate's `Store<S>` on every transition. That blob is fine for
- * crash recovery of the *runtime* — but it is NOT a coarse, named checkpoint a
- * human (or a separate recovery job) can point a restart at. `snapshot` adds
- * the "every N units of progress, write a durable checkpoint to R2/KV"
- * discipline on top, so a crashed long run restarts from the last checkpoint
- * instead of from zero (the field-guide pain row).
- *
- * Shape: this is the same knob contract every L2 composition follows —
- * `createSnapshot(config)` hands back a `{ init, <verbs>, handlers }` bundle you
- * splice into your machine. The state it owns is a Model slice (durable +
- * replayable, the two non-negotiables); the verbs are PURE decisions; the I/O
- * (the actual `put` to the store) lives only in `handlers`.
- *
- * It is a LEAF module: it imports only the core substrate (`../index`, for
- * `Cmd` / `Interpret`) and no sibling subpath. (It does NOT reuse
- * `@demlik/tea/retry-backoff` — that is an even-leafier utility that depends on
- * nothing at all, not even the core; the kinship here is "leaf with injected
- * time", not a shared dependency.)
- * Nothing here reads the clock or the RNG on its own behalf — time enters as an
- * `at`/`now` parameter at the verb boundary and the store I/O is realized only
- * when the runtime performs the emitted `Cmd`. That keeps every verb
- * deterministic (invariant 2) and the checkpoint write a `Cmd` the runtime
- * interprets (invariant 3).
- *
- * The Store port is deliberately ABSTRACT — `{ get, put }`, the lowest common
- * shape of R2 and KV — so this module never imports `@cloudflare/workers-types`
- * and can be checkpointed to anything (R2, KV, a DO sub-key, an in-memory map in
- * tests). The host binds the concrete adapter at `handlers({ store })`.
- *
- * Typical wiring:
- *
- *   const snap = createSnapshot<RunState>({ every: 25, key: "run/checkpoint" });
- *
- *   // machine state:
- *   type State = { run: RunState; snapshot: SnapshotState };
- *   init: (loaded) => loaded ? [loaded, []] : [{ run: initRun(), snapshot: snap.init() }, []],
- *
- *   // in `update`, on each progress Msg, fold the snapshot slice:
- *   progress: (s, msg) => {
- *     const run = advance(s.run, msg);
- *     const [snapshot, cmds] = snap.record(s.snapshot, run, msg.at);
- *     return [{ ...s, run, snapshot }, cmds];
- *   },
- *   // the write completed → durable ack folds back through update:
- *   snapshot_saved: (s, msg) => {
- *     const [snapshot, cmds] = snap.confirm(s.snapshot, msg);
- *     return [{ ...s, snapshot }, cmds];
- *   },
- *
- *   // RECOVERY — the half that makes a checkpoint a restart point, not just a
- *   // backup. A `boot` Msg the host dispatches once after `run(...)` asks the
- *   // store for the durable checkpoint; the answer folds the recovered payload
- *   // back into the run slice:
- *   boot: (s) => snap.requestLoad(s),                       // emits snapshot_load Cmd
- *   snapshot_loaded: (s, msg) => {
- *     if (msg.payload === null) return [s, []];             // no checkpoint → keep fresh init
- *     const [snapshot, cmds] = snap.boot(s.snapshot);
- *     return [{ ...s, run: msg.payload, snapshot }, cmds];
- *   },
- *   snapshot_load_failed: (s) => [s, []],                   // errors are data — decide here
- *
- *   // splice the I/O — both effect cells (write + load):
- *   interpret: { ...snap.handlers({ store: r2Adapter }) },
- */
+import { a as CmdOf, b as CmdDef, C as Cmd, I as Interpret } from './core-CTzMJ82M.js';
 
 /**
  * The snapshot knob.
@@ -162,13 +92,20 @@ interface SnapshotPorts<V> {
  * state, the cursor, whatever the machine wants restartable). The verb takes it
  * as an argument so the snapshot slice never has to hold a copy of the
  * machine's domain state.
+ *
+ * `Cmd.define`d (ADR 0014), minted per `V` by a factory the way
+ * `workflowActivityDef<A>()` is, since the payload type is the knob's own
+ * parameter. The handler answers through this module's OWN Msgs
+ * (`snapshot_saved` / `snapshot_failed`), never the minted `_ok` / `_err`,
+ * hence `ok: z.void()` and an empty `err` list.
  */
-type SnapshotWriteCmd<V> = Cmd<"snapshot_write"> & {
+declare function snapshotWriteDef<V>(): CmdDef<"snapshot_write", {
     readonly key: string;
     readonly seq: number;
     readonly at: number;
     readonly payload: V;
-};
+}, void, never, unknown>;
+type SnapshotWriteCmd<V> = CmdOf<ReturnType<typeof snapshotWriteDef<V>>>;
 /**
  * The Msg the write handler dispatches on a SUCCESSFUL `put`. Fold it back
  * through `confirm(state, msg)` to advance `lastSavedSeq` / `lastSavedAt`. The
@@ -203,9 +140,10 @@ type SnapshotFailedMsg = {
  * 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.
  */
-type SnapshotLoadCmd = Cmd<"snapshot_load"> & {
-    readonly key: string;
-};
+declare const snapshotLoad: CmdDef<"snapshot_load", {
+    key: string;
+}, void, never, unknown>;
+type SnapshotLoadCmd = CmdOf<typeof snapshotLoad>;
 /**
  * The Msg the load handler dispatches when `store.get` RESOLVES. `payload` is
  * the recovered checkpoint value, or `null` when the store has no checkpoint
@@ -331,4 +269,4 @@ interface SnapshotKnob<V> {
  */
 declare function createSnapshot<V>(config: SnapshotConfig): SnapshotKnob<V>;
 
-export { type SnapshotConfig, type SnapshotFailedMsg, type SnapshotKnob, type SnapshotLoadCmd, type SnapshotLoadFailedMsg, type SnapshotLoadedMsg, type SnapshotPorts, type SnapshotSavedMsg, type SnapshotState, type SnapshotStore, type SnapshotWriteCmd, createSnapshot, snapshotFailed, snapshotLoadFailed, snapshotLoaded, snapshotSaved };
+export { type SnapshotWriteCmd as S, type SnapshotState as a, type SnapshotStore as b, type SnapshotSavedMsg as c, type SnapshotFailedMsg as d, type SnapshotLoadedMsg as e, type SnapshotLoadFailedMsg as f, type SnapshotLoadCmd as g, type SnapshotConfig as h, type SnapshotKnob as i, type SnapshotPorts as j, createSnapshot as k, snapshotLoad as l, snapshotLoadFailed as m, snapshotLoaded as n, snapshotSaved as o, snapshotWriteDef as p, snapshotFailed as s };

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

@@ -1,14 +1,10 @@
-import { DeadlineExceeded, DeadlineSub } from '../deadline/index.js';
-export { deadlineSub, subscribeDeadline } from '../deadline/index.js';
-import { I as Interpret, C as Cmd } from '../core-Bjc0bS8j.js';
-import { SnapshotWriteCmd, SnapshotState, SnapshotStore, SnapshotSavedMsg, SnapshotFailedMsg, SnapshotLoadedMsg, SnapshotLoadFailedMsg, SnapshotLoadCmd } from '../snapshot/index.js';
-import { QueueItem } from '../work-queue/index.js';
-import '../types-D7u9DkH7.js';
-import '../runtime-types-Bxc637bp.js';
-import 'better-result';
+import { I as Interpret, C as Cmd } from './core-CTzMJ82M.js';
+import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotStore, c as SnapshotSavedMsg, d as SnapshotFailedMsg, e as SnapshotLoadedMsg, f as SnapshotLoadFailedMsg, g as SnapshotLoadCmd } from './index-DMCeMPMJ.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
+import { Q as QueueItem } from './index-DJWIER_3.js';
 
 /**
- * @demlik/tea/monitored-run — a long-running operation that is BOTH staged and
+ * internal/flow/monitored-run — a long-running operation that is BOTH staged and
  * watched: an ordered stage pipeline whose POSITION survives eviction, wrapped
  * by a no-progress safety deadline and (optionally) a periodic durable
  * checkpoint.
@@ -45,7 +41,7 @@ import 'better-result';
  *
  * ## Why the run lifecycle is INLINE (run-tracker not extracted)
  *
- * The phase union (`idle` / `running` / `stale` / `done` / `failed`, a
+ * The phase union (`idle` / `running` / `stale` / `done` / `failed` / `cancelled`, a
  * discriminated union carrying only each phase's own data) and its bookkeeping
  * (`runId`, `startedAt`, `lastProgressAt`, `progressSeq`) live directly on this
  * slice rather than behind a `run-tracker` sub-knob.
@@ -202,10 +198,19 @@ interface RunCore<Stage> {
  *   - `failed`  — terminal failure; the typed `failure` reason rides ONLY this
  *                 arm, so it is present iff `phase === "failed"` BY CONSTRUCTION —
  *                 there is no nullable side field to keep in sync.
+ *   - `cancelled` — the consumer stopped the run from outside (`cancel`). Its own
+ *                 phase rather than a `RunFailure` reason, on the same argument
+ *                 that keeps `stale` a phase: a caller who asked for the stop did
+ *                 not suffer a failure, and every "did this fail?" reader would
+ *                 otherwise have to except one reason. Terminal, so it re-enters
+ *                 no verb and arms no watchdog.
  *
  * `runId` is the host-minted run identity, stamped at `start` (the machine never
  * mints — see the audit seed's "run identity is host-minted"). It rides every
- * started phase, but not `idle`.
+ * started phase, but not `idle`. `cancelled` is the one phase reachable from BOTH
+ * sides of that line, so its `runId` is `string | null`: `null` says the run was
+ * cancelled before it ever started and there was no identity to mint, which is a
+ * different fact from a cancelled live run and stays a different value.
  */
 type MonitoredRunState<Stage> = (RunCore<Stage> & {
     readonly phase: "idle";
@@ -222,7 +227,26 @@ type MonitoredRunState<Stage> = (RunCore<Stage> & {
     readonly phase: "failed";
     readonly runId: string;
     readonly failure: RunFailure<Stage>;
+}) | (RunCore<Stage> & {
+    readonly phase: "cancelled";
+    readonly runId: string | null;
+    readonly at: number;
 });
+/**
+ * The ENDED phases — a run that finished (`done`) or was stopped from outside
+ * (`cancelled`). Every arm here was started or explicitly stopped, so `idle` is
+ * out and `runId` is present on the whole union: a consumer holding one of these
+ * reads the run identity without a `phase` guard the value can never fail.
+ *
+ * It is the resolved half of a drive: a promise that resolves only on an ended
+ * run should say so in its type rather than resolve `MonitoredRunState` and
+ * leave every reader to re-prove the `idle` arm impossible (#155). `cancelled`
+ * keeps its `string | null` `runId` unchanged — a run cancelled before it ever
+ * started genuinely has no identity, and that stays a different value here.
+ */
+type EndedRun<Stage> = Extract<MonitoredRunState<Stage>, {
+    readonly phase: "done" | "cancelled";
+}>;
 /**
  * The outcome a consumer reports to `advance`: the current stage either
  * succeeded (retire it, claim the next) or failed (terminate the run). Plain
@@ -258,6 +282,7 @@ declare function createMonitoredRun<Stage, V = unknown>(config?: MonitoredRunCon
     start: (s: MonitoredRunState<Stage>, runId: string, at: number) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
     progress: (s: MonitoredRunState<Stage>, payload: V, at: number) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
     markStale: (s: MonitoredRunState<Stage>) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
+    cancel: (s: MonitoredRunState<Stage>, at: number) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
     advance: (s: MonitoredRunState<Stage>, payload: V, result: StageResult, at: number) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
     onDeadline: (s: MonitoredRunState<Stage>, msg: MonitoredRunTimerMsg) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
     boot: (s: MonitoredRunState<Stage>, at: number) => readonly [MonitoredRunState<Stage>, readonly MonitoredRunCmd<V>[]];
@@ -275,4 +300,4 @@ declare function liftRun<S extends {
     run: MonitoredRunState<Stage>;
 }, Stage, C extends Cmd>(state: S, [slice, cmds]: readonly [MonitoredRunState<Stage>, readonly C[]]): readonly [S, readonly C[]];
 
-export { DeadlineExceeded, DeadlineSub, type MonitoredRunCmd, type MonitoredRunConfig, type MonitoredRunPorts, type MonitoredRunState, type MonitoredRunTimerMsg, type RunFailure, SnapshotSavedMsg, SnapshotWriteCmd, type StageResult, createMonitoredRun, liftRun };
+export { type EndedRun as E, type MonitoredRunCmd as M, type RunFailure as R, type StageResult as S, type MonitoredRunState as a, type MonitoredRunConfig as b, type MonitoredRunPorts as c, type MonitoredRunTimerMsg as d, createMonitoredRun as e, liftRun as l };

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

@@ -1,6 +1,4 @@
-import { B as BootingRuntime } from '../runtime-types-Bxc637bp.js';
-import 'better-result';
-import '../core-Bjc0bS8j.js';
+import { B as BootingRuntime } from './runtime-types-LWDoi943.js';
 
 /**
  * A recorded run, sufficient to reproduce it via `../trace-replay`.
@@ -220,7 +218,7 @@ interface TraceAttachment {
  *
  * ```ts
  * import * as Sentry from "@sentry/browser"; // or "@sentry/node"
- * import { traceAttachment } from "@demlik/tea/recorder";
+ * import { traceAttachment } from "./internal/persistence/recorder"; // internal module
  * Sentry.getCurrentScope().addAttachment(traceAttachment(rec.dump()));
  * ```
  *
@@ -278,7 +276,7 @@ interface BreadcrumbsOptions<M> {
  *
  * ```ts
  * import * as Sentry from "@sentry/browser"; // or "@sentry/node"
- * import { breadcrumbsFromTrace } from "@demlik/tea/recorder";
+ * import { breadcrumbsFromTrace } from "./internal/persistence/recorder"; // internal module
  * for (const b of breadcrumbsFromTrace(rec.dump())) Sentry.addBreadcrumb(b);
  * ```
  *
@@ -289,4 +287,4 @@ declare function breadcrumbsFromTrace<S, M extends {
     type: string;
 }>(trace: Trace<S, M>, opts?: BreadcrumbsOptions<M>): TraceBreadcrumb[];
 
-export { type BreadcrumbsOptions, type Recorder, type RecorderOptions, type Trace, type TraceAttachment, type TraceBreadcrumb, breadcrumbsFromTrace, parseJSONL, recorder, traceAttachment };
+export { type BreadcrumbsOptions as B, type RecorderOptions as R, type Trace as T, type Recorder as a, type TraceAttachment as b, type TraceBreadcrumb as c, breadcrumbsFromTrace as d, parseJSONL as p, recorder as r, traceAttachment as t };