@demlik/tea 0.17.0 → 0.19.0

package/dist/idempotency/index.d.ts

@@ -1,9 +1,9 @@
 import { I as IdempotencyStore } from '../index-Bc40JWVl.js';
 export { a as IdempotencyEntry, e as evictExpired, i as initStore, r as recall, b as remember, s as seen } from '../index-Bc40JWVl.js';
-import { c as CmdOf, b as CmdDef } from '../core-rDbOaJTN.js';
-import { Q as QueueItem } from '../index-CcrKLtse.js';
+import { a as CmdOf, b as CmdDef } from '../core-Ce9ncpuv.js';
+import { Q as QueueItem } from '../index-DWdg7R1l.js';
 import '@standard-schema/spec';
-import '../runtime-types-B62Ucnxr.js';
+import '../runtime-types-BKg2CGMx.js';
 
 /**
  * A cached intake entry: either a key whose work is still in flight

package/dist/idempotency/index.js

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

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

@@ -1,6 +1,6 @@
-import { c as CmdOf, b as CmdDef, g as TaggedError, q as MalformedResult, T as TimerDeps, C as Cmd } from './core-rDbOaJTN.js';
+import { a as CmdOf, b as CmdDef, f as TaggedError, n as MalformedResult, T as TimerDeps, C as Cmd } from './core-Ce9ncpuv.js';
 import { RetryState, AnyRetryPolicy } from './retry-backoff/index.js';
-import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-DaX_P35Q.js';
+import { T as TtlCache, D as DeadlineExceeded, a as DeadlineSub } from './index-e36uEyl4.js';
 
 /**
  * @packageDocumentation

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

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

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

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

package/dist/index-BnsAqn0-.d.ts

@@ -0,0 +1,286 @@
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { Effect, Stream, Scope } from 'effect';
+import { P as Port, C as Cmd, v as ErrorsOf, J as OkOfCmd, u as DeclaredErrorsOf, c as Sub, s as BuiltinSubType, B as BuiltinSub, M as Machine } from './core-Ce9ncpuv.js';
+import { f as DispatchSettle, C as CtxArg, S as Store, O as OnError, a as Supervision, T as TelemetrySink } from './runtime-types-BKg2CGMx.js';
+
+declare const Stopped_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "Stopped";
+} & Readonly<A>;
+/**
+ * A dispatch the run refused because it is stopping or has stopped. The Msg
+ * was never folded.
+ *
+ * `when` is `"stopping"` for a Msg that arrived while `stop()` (or a closing
+ * Scope) drained the run's in-flight work, and `"stopped"` once it had.
+ */
+declare class Stopped extends Stopped_base<{
+    readonly msgType: string;
+    readonly when: "stopping" | "stopped";
+}> {
+    get message(): string;
+}
+declare const StoreFailed_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "StoreFailed";
+} & Readonly<A>;
+/**
+ * The run's store failed. `operation` is `"load"` when the saved state could
+ * not be restored at boot — `cause` is then the `StoreRefusedError` that says
+ * why — and `"save"` when a transition's save threw, a fenced store's
+ * `StoreConflictError` included; `cause` is then the store's own throw.
+ */
+declare class StoreFailed extends StoreFailed_base<{
+    readonly operation: "load" | "save";
+    readonly cause: unknown;
+}> {
+    get message(): string;
+}
+
+/**
+ * The Effect engine's run handle (#308, ruling R4.1 of #325). Its members have
+ * the Promise engine's names (the shared-handle ruling of #250); only the
+ * return types differ. Each member that returns a Promise there returns an
+ * Effect here, with a typed error channel a host reads with `Effect.catchTags`.
+ * Members that neither wait nor fail — `getState`, `result` and the listener
+ * registrations — are the same functions on both engines.
+ */
+
+/**
+ * What the Effect engine's `run` yields while boot is in flight. `Err` is the
+ * union of the declared failures of the run's hand-written cells: a dispatch
+ * whose Cmd's cell fails with one fails with it. Reading State and waiting for
+ * quiescence need boot to have run, so they live on the {@link EffectRuntime}
+ * that `ready` succeeds with.
+ */
+interface EffectBootingRuntime<S, M extends {
+    type: string;
+}, E extends {
+    type: string;
+} = never, Err = never> {
+    /**
+     * Fold `msg` and run to quiescence, as the Promise engine's `dispatch` does.
+     * Fails with `Stopped` once the run is stopping or stopped, `StoreFailed`
+     * when the transition's save fails, and a hand-written cell's declared
+     * failure when the transition's Cmd fails with one.
+     */
+    dispatch(msg: M, opts?: {
+        readonly settle?: DispatchSettle;
+    }): Effect.Effect<void, Err | Stopped | StoreFailed>;
+    /** `dispatch(msg, { settle: "once" })`: one transition, no follow-up drain. */
+    dispatchOnce(msg: M): Effect.Effect<void, Err | Stopped | StoreFailed>;
+    /** A zero-arg change notifier, fired after each applied transition. */
+    subscribe(listener: () => void): () => void;
+    /** A `(msg, state)` hook, fired after each applied transition. */
+    observe(observer: (msg: M, state: S) => void): () => void;
+    /** Fires once with the initial State — at once if boot already ran. */
+    onBoot(handler: (state: S) => void): () => void;
+    /** Subscribe to the semantic event of `type` the run's `events` projects. */
+    on<K extends E["type"]>(type: K, handler: (event: Extract<E, {
+        type: K;
+    }>) => void): () => void;
+    /** Subscribe to a typed Port. */
+    subscribePort<T>(port: Port<T>, listener: (value: T) => void): () => void;
+    /** Emit a value on a Port from outside a Cmd handler. */
+    emitPort<T>(port: Port<T>, value: T): void;
+    /**
+     * Succeeds with the booted handle once boot completes. Fails with
+     * `StoreFailed` when the saved state could not be restored (`"load"`) or the
+     * initial save failed (`"save"`), and with a hand-written cell's declared
+     * failure when a boot Cmd fails with one.
+     */
+    readonly ready: Effect.Effect<EffectRuntime<S, M, E, Err>, Err | StoreFailed>;
+    /**
+     * Stop the run: drain in-flight work, stop its Subs, flush the final State.
+     * Closing the run's Scope does the same.
+     */
+    stop(): Effect.Effect<void>;
+}
+/** The Effect engine's booted handle — what `ready` succeeds with. */
+interface EffectRuntime<S, M extends {
+    type: string;
+}, E extends {
+    type: string;
+} = never, Err = never> extends EffectBootingRuntime<S, M, E, Err> {
+    /** The current State. Total. */
+    getState(): S;
+    readonly ready: Effect.Effect<EffectRuntime<S, M, E, Err>, Err | StoreFailed>;
+    /** Succeeds once every dispatched Msg and its follow-ups are processed. */
+    idle(): Effect.Effect<void>;
+    /** The terminal State, or `undefined` while the run is in flight. */
+    result(): S | undefined;
+    /** Succeeds with the terminal State the first time the run reaches one. */
+    done(): Effect.Effect<S>;
+}
+
+/**
+ * The Effect engine's `run` (#283): the same machine the Promise engine runs,
+ * with Effect handlers, Effect sub runners, the caller's Layers and
+ * interruption on stop.
+ *
+ * It runs the one core loop both engines share (`src/internal/engine/loop.ts`)
+ * with the same built-ins in the same order, so a machine folds the same way on
+ * either engine. What this file adds is the Effect edge:
+ *
+ *   - an `interpret` cell returns `Effect<Ok, E, R>`, read with
+ *     `Effect.result`: a success settles `_ok`, a declared failure settles
+ *     `_err`, a defect goes to the error sink;
+ *   - a `subscribe` runner returns a `Stream<Msg>`, drained on its own fiber;
+ *   - every handler and runner fiber runs with the services the caller
+ *     provided, so `R` reaches them from the caller's Layers;
+ *   - stopping interrupts every handler fiber still in flight;
+ *   - the handle's verbs are Effects with a typed error channel
+ *     (`./handle`, `./failures`).
+ */
+
+/**
+ * One Effect `interpret` cell. For a `Cmd.define`d Cmd it succeeds with the
+ * Cmd's `Ok` and fails with one of its declared tags, and the engine mints
+ * `<name>_ok` / `<name>_err` from that (ADR 0021). For a hand-written Cmd it
+ * succeeds with a follow-up Msg, a list of them (dispatched in order), or
+ * nothing, and its failure fails the dispatch with that error, typed on the
+ * handle (see {@link CellErrors}). `R` is whatever services it reads.
+ */
+type EffectInterpretCell<M extends {
+    type: string;
+}, C extends Cmd, R = unknown> = unknown extends ErrorsOf<C> ? (cmd: C) => Effect.Effect<M | readonly M[] | void, unknown, R> : (cmd: C) => Effect.Effect<OkOfCmd<C>, DeclaredErrorsOf<C>, R>;
+/**
+ * The Effect engine's `interpret` map: one cell per Cmd variant, each reading
+ * services within `R`.
+ */
+type EffectInterpret<M extends {
+    type: string;
+}, C extends Cmd, R = unknown> = {
+    readonly [K in C["type"]]: EffectInterpretCell<M, Extract<C, {
+        type: K;
+    }>, R>;
+};
+/**
+ * One Effect sub runner: the Sub in, a `Stream` of Msgs out. The engine drains
+ * it on its own fiber and interrupts that fiber when the Sub stops.
+ *
+ * A Sub maps the errors it expects into Msgs itself, the way an Elm `Sub msg`
+ * carries no error type: `Stream.catchTag("Closed", () => Stream.make({ type:
+ * "disconnected" }))`. A stream that still fails reaches the error sink under
+ * `"sub"` and stops the run: the run's Scope closes with that failure (#309).
+ */
+type EffectRunner<M extends {
+    type: string;
+}, U extends Sub, R = unknown> = (sub: U) => Stream.Stream<M, unknown, R>;
+/**
+ * The Effect engine's `subscribe` map: a runner for every Sub type the machine
+ * declares beyond the built-ins, and optionally one for a built-in, which
+ * replaces the engine's own (#270 R2.1).
+ */
+type EffectSubscribe<M extends {
+    type: string;
+}, U extends Sub, R = unknown> = {
+    readonly [K in Exclude<U["type"], BuiltinSubType>]: EffectRunner<M, Extract<U, {
+        type: K;
+    }>, R>;
+} & {
+    readonly [K in BuiltinSubType]?: EffectRunner<M, Extract<BuiltinSub<M>, {
+        type: K;
+    }>, R>;
+};
+/** The services every cell of an `interpret` map reads. */
+type InterpretServices<I> = {
+    [K in keyof I]: ServicesOfCell<I[K]>;
+}[keyof I];
+type ServicesOfCell<F> = F extends (cmd: never) => Effect.Effect<unknown, unknown, infer R> ? R : never;
+/**
+ * The failures a dispatch on the handle can end with from an `interpret` map:
+ * the error type of every hand-written Cmd's cell. A `Cmd.define`d Cmd's
+ * declared failure settles its `_err` Msg instead, so it adds nothing here.
+ */
+type CellErrors<C extends Cmd, I> = {
+    [K in keyof I & C["type"]]: unknown extends ErrorsOf<Extract<C, {
+        type: K;
+    }>> ? ErrorOfCell<I[K]> : never;
+}[keyof I & C["type"]];
+type ErrorOfCell<F> = F extends (cmd: never) => Effect.Effect<unknown, infer Err, unknown> ? Err : never;
+/** The services every runner of a `subscribe` map reads. */
+type SubscribeServices<B> = {
+    [K in keyof B]-?: ServicesOfRunner<NonNullable<B[K]>>;
+}[keyof B];
+type ServicesOfRunner<F> = F extends (sub: never) => Stream.Stream<unknown, unknown, infer R> ? R : never;
+type InterpretOption<C extends Cmd, I> = [C] extends [Cmd<never>] ? {
+    readonly interpret?: I;
+} : {
+    readonly interpret: I;
+};
+type SubscribeOption<U extends Sub, B> = [
+    Exclude<U["type"], BuiltinSubType>
+] extends [never] ? {
+    readonly subscribe?: B;
+} : {
+    readonly subscribe: B;
+};
+/**
+ * The options of the Effect engine's `run`. Beside `interpret` and
+ * `subscribe`, they are the Promise engine's, with the same meaning; see `run`
+ * in `@demlik/tea/promise` for each one's contract.
+ */
+type EffectRunOptions<S, M extends {
+    type: string;
+}, C extends Cmd, U extends Sub, Ctx, E extends {
+    type: string;
+}, I, B> = CtxArg<Ctx> & InterpretOption<C, I> & SubscribeOption<U, B> & {
+    readonly store?: Store<S>;
+    readonly onError?: OnError;
+    /** Stamps `at` on minted Msgs and telemetry. Defaults to `Date.now`. */
+    readonly clock?: () => number;
+    /** Projects each applied transition to the public events `on` serves. */
+    readonly events?: (msg: M, state: S) => readonly E[];
+    /** The policy for a reducer throw. Defaults to `"stop"`. */
+    readonly supervision?: Supervision<S, M>;
+    /** The terminal predicate `result()` and `done()` read. */
+    readonly terminal?: (state: S) => boolean;
+    /** A fire-and-forget sink for every applied transition. */
+    readonly telemetry?: TelemetrySink;
+    /** How long `stop()` waits for async teardown. Defaults to 5_000ms. */
+    readonly disposeTimeoutMs?: number;
+};
+/**
+ * Run `machine` on the Effect engine. The returned Effect needs a `Scope` and
+ * the services its handlers and runners read, and yields the run handle. The
+ * handle's members have the Promise engine's names; the ones that return a
+ * Promise there return an Effect here, failing with `Stopped`, `StoreFailed`
+ * or a hand-written cell's declared failure, so a host sorts them with
+ * `Effect.catchTags`.
+ *
+ * Closing the scope stops the run and its Subs: every handler still in flight
+ * is interrupted (its finalizers run), its Msg is never dispatched, and a
+ * dispatch after stop fails with `Stopped`. The handle's `stop()` does the
+ * same.
+ *
+ * A Sub whose Stream fails with an error it did not map to a Msg stops the
+ * run the other way round: the engine closes that Scope with the failure.
+ *
+ * A fenced store is fenced here exactly as on the Promise engine: the check is
+ * one of the built-ins both engines run.
+ *
+ * ```ts
+ * const program = Effect.gen(function* () {
+ *   const handle = yield* run(machine, {
+ *     interpret: {
+ *       fetch: (cmd) =>
+ *         Effect.gen(function* () {
+ *           const api = yield* Api;
+ *           return yield* api.get(cmd.id);
+ *         }),
+ *     },
+ *   });
+ *   const runtime = yield* handle.ready;
+ *   yield* runtime.dispatch({ type: "go", id: "7" });
+ *   return runtime.getState();
+ * });
+ * Effect.runPromise(program.pipe(Effect.scoped, Effect.provide(ApiLive)));
+ * ```
+ */
+declare function run<S, M extends {
+    type: string;
+}, C extends Cmd, U extends Sub, Ctx, I extends EffectInterpret<M, C> = EffectInterpret<M, C, never>, B extends EffectSubscribe<M, U> = EffectSubscribe<M, U, never>, E extends {
+    type: string;
+} = never>(machine: Machine<S, M, C, U, Ctx>, opts: EffectRunOptions<S, M, C, U, Ctx, E, I, B>): Effect.Effect<EffectBootingRuntime<S, M, E, CellErrors<C, I>>, never, Scope.Scope | InterpretServices<I> | SubscribeServices<B>>;
+
+export { type CellErrors as C, type EffectInterpret as E, type InterpretServices as I, type SubscribeOption as S, type EffectSubscribe as a, type SubscribeServices as b, type EffectBootingRuntime as c, type EffectInterpretCell as d, type EffectRunOptions as e, type EffectRunner as f, type EffectRuntime as g, Stopped as h, StoreFailed as i, run as r };

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

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

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

@@ -1,4 +1,4 @@
-import { c as CmdOf, b as CmdDef, e as SettledOk, f as SettledErr, g as TaggedError, C as Cmd } from './core-rDbOaJTN.js';
+import { a as CmdOf, b as CmdDef, d as SettledOk, e as SettledErr, f as TaggedError, C as Cmd } from './core-Ce9ncpuv.js';
 
 /**
  * The snapshot knob.

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

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

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

@@ -1,7 +1,7 @@
-import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-rDbOaJTN.js';
-import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-CWmsXNdX.js';
-import { D as DeadlineExceeded, a as DeadlineSub } from './index-DaX_P35Q.js';
-import { Q as QueueItem } from './index-CcrKLtse.js';
+import { b as CmdDef, T as TimerDeps, C as Cmd } from './core-Ce9ncpuv.js';
+import { S as SnapshotWriteCmd, a as SnapshotState, b as SnapshotSavedMsg } from './index-D8sYVzCI.js';
+import { D as DeadlineExceeded, a as DeadlineSub } from './index-e36uEyl4.js';
+import { Q as QueueItem } from './index-DWdg7R1l.js';
 
 /**
  * The monitored-run knob. EVERY field is optional:
@@ -223,4 +223,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 { 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 MonitoredRunTimerMsg as c, createMonitoredRun as d, liftRun as l };
+export { type EndedRun as E, type MonitoredRunCmd as M, type RunFailure as R, type StageResult as S, type MonitoredRunConfig as a, type MonitoredRunState as b, type MonitoredRunTimerMsg as c, createMonitoredRun as d, liftRun as l };

package/dist/{index-DaX_P35Q.d.ts → index-e36uEyl4.d.ts}

@@ -1,5 +1,5 @@
-import { m as SubId, S as Sub, n as DepKeyedSub, h as Dispose, T as TimerDeps } from './core-rDbOaJTN.js';
-import { S as SubscribeHandler } from './types-DPm5YCDQ.js';
+import { k as SubId, c as Sub, l as DepKeyedSub, D as Dispose, T as TimerDeps } from './core-Ce9ncpuv.js';
+import { S as SubscribeHandler } from './types-SzNSHKlV.js';
 
 /**
  * internal/resilience/deadline — a one-shot Sub that fires when an ABSOLUTE wall-clock
@@ -413,4 +413,4 @@ declare function cacheEvictionSub(name: string, everyMs: number): DepKeyedSub<un
  */
 declare const cacheEvictionSubscribe: SubscribeHandler<CacheEvictionSub, CacheEvictMsg, unknown>;
 
-export { type ArmTimer as A, type CacheEvictionSub as C, type DeadlineExceeded as D, type TtlCache as T, type DeadlineSub as a, type DeadlinesSub as b, deadlineSub as c, deadlineExceeded as d, deadlinesSub as e, type CacheEvictMsg as f, type CacheEntry as g, type CacheEvictionDeps as h, type DeadlineMsgType as i, type DeadlineOpts as j, cacheEvictMsg as k, cacheEvictionSub as l, cacheEvictionSubscribe as m, deadlineMsgType as n, deadlines as o, evictExpired as p, get as q, has as r, subscribeDeadline as s, initCache as t, nextTimer as u, remove as v, set as w, setTimeoutArmTimer as x, subscribeWith as y };
+export { type ArmTimer as A, type CacheEvictionSub as C, type DeadlineExceeded as D, type TtlCache as T, type DeadlineSub as a, type DeadlinesSub as b, type CacheEvictMsg as c, deadlineExceeded as d, type CacheEntry as e, type CacheEvictionDeps as f, type DeadlineMsgType as g, type DeadlineOpts as h, cacheEvictMsg as i, cacheEvictionSub as j, cacheEvictionSubscribe as k, deadlineMsgType as l, deadlineSub as m, deadlines as n, deadlinesSub as o, evictExpired as p, get as q, has as r, subscribeDeadline as s, initCache as t, nextTimer as u, remove as v, set as w, setTimeoutArmTimer as x, subscribeWith as y };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { B as BootingRuntime, R as Runtime } from './runtime-types-B62Ucnxr.js';
-export { b as BootedRunHandle, d as Branded, C as CtxArg, D as DispatchDiscardedError, e as DispatchSettle, f as DisposeTimeoutNotice, g as DriveFailedError, h as DriveStalledError, E as EngineRun, i as FencedRead, F as FencedStore, j as FoldRefusal, I as IdentityDropNotice, M as MachineTypes, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, c as RunHandle, k as RunOptions, l as RuntimeDiscardNotice, m as RuntimeDiscardedError, n as RuntimeErrorContext, o as RuntimeErrorPhase, p as RuntimeRef, q as Schema, S as Store, r as StoreConflictError, a as Supervision, s as SupervisionStrategy, t as TelemetryEvent, T as TelemetrySink, _ as __resetPortRegistry, u as absurd, v as asReducer, w as defineMachine, x as definePort, y as isFencedStore, z as noop, A as replay, G as schemaMigrate, H as tryApplyCell, J as tryFoldMsgs, K as tryInterpret, L as wrapDetached } from './runtime-types-B62Ucnxr.js';
-import { C as Cmd, S as Sub, M as Machine, P as Port, n as DepKeyedSub, h as Dispose } from './core-rDbOaJTN.js';
-export { A as AnyCmdDef, v as AsyncSchemaError, a as BuiltinSub, B as BuiltinSubType, b as CmdDef, w as CmdInput, c as CmdOf, u as CmdValue, D as DeclaredErrorsOf, t as ErrOf, E as ErrorsOf, x as ExhaustiveTransitions, y as Identity, o as Interpret, z as InterpretArg, F as InterpretCell, I as InterpretDetached, G as MachineShape, q as MalformedResult, N as NoCellError, J as NoCtx, s as OkOf, O as OkOfCmd, l as Outcome, K as OutcomeContractError, L as OutcomeHelpers, Q as PortEmitter, i as Reducer, R as RunHandlers, j as Settled, f as SettledErr, e as SettledOk, m as SubId, d as Subscribe, V as SubscribeArg, X as SyncReturn, r as Tagged, g as TaggedError, T as TimerDeps, p as TimerSub, k as Transitions, Y as UndeclaredFailureError, U as UpdateForm, W as Wired, Z as acceptedTypes, _ as acceptsOf, $ as applyCell, a0 as applyCellChecked, a1 as describeMachine, a2 as detectUpdateForm, a3 as foldMsgs, a4 as foldUpdates, a5 as formOf, a6 as msgKeysOf, a7 as structuralHash, a8 as subId, a9 as subIdOf } from './core-rDbOaJTN.js';
-import { S as SubscribeHandler } from './types-DPm5YCDQ.js';
+import { B as BootingRuntime, R as Runtime } from './runtime-types-BKg2CGMx.js';
+export { b as BootedRunHandle, d as Branded, C as CtxArg, D as DeletableStore, e as DispatchDiscardedError, f as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, E as EngineRun, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, l as MachineTypes, M as Migrated, O as OnError, P as PortNameCollisionError, Q as QuiescenceTimeoutError, m as Refusal, c as RunHandle, n as RunOptions, o as RuntimeDiscardNotice, p as RuntimeDiscardedError, q as RuntimeErrorContext, r as RuntimeErrorPhase, s as RuntimeRef, t as Schema, S as Store, u as StoreConflictError, v as StoreRefusedError, a as Supervision, w as SupervisionStrategy, x as TelemetryEvent, T as TelemetrySink, _ as __resetPortRegistry, y as absurd, z as asReducer, A as defineMachine, G as definePort, H as isFencedStore, J as noop, K as refuse, L as replay, N as schemaMigrate, U as tryApplyCell, V as tryFoldMsgs, W as tryInterpret, X as wrapDetached } from './runtime-types-BKg2CGMx.js';
+import { C as Cmd, c as Sub, M as Machine, P as Port, l as DepKeyedSub, D as Dispose } from './core-Ce9ncpuv.js';
+export { A as AnyCmdDef, r as AsyncSchemaError, B as BuiltinSub, s as BuiltinSubType, b as CmdDef, t as CmdInput, a as CmdOf, q as CmdValue, u as DeclaredErrorsOf, E as ErrOf, v as ErrorsOf, w as ExhaustiveTransitions, x as Identity, I as Interpret, y as InterpretArg, z as InterpretCell, j as InterpretDetached, F as MachineShape, n as MalformedResult, N as NoCellError, G as NoCtx, p as OkOf, J as OkOfCmd, O as Outcome, K as OutcomeContractError, L as OutcomeHelpers, Q as PortEmitter, g as Reducer, R as RunHandlers, h as Settled, e as SettledErr, d as SettledOk, k as SubId, S as Subscribe, V as SubscribeArg, X as SyncReturn, o as Tagged, f as TaggedError, T as TimerDeps, m as TimerSub, i as Transitions, Y as UndeclaredFailureError, U as UpdateForm, W as Wired, Z as acceptedTypes, _ as acceptsOf, $ as applyCell, a0 as applyCellChecked, a1 as describeMachine, a2 as detectUpdateForm, a3 as foldMsgs, a4 as foldUpdates, a5 as formOf, a6 as msgKeysOf, a7 as structuralHash, a8 as subId, a9 as subIdOf } from './core-Ce9ncpuv.js';
+import { S as SubscribeHandler } from './types-SzNSHKlV.js';
 import '@standard-schema/spec';
 
 /**
@@ -456,29 +456,65 @@ interface ManagedResourceBattery<N extends string, TKey, Handle, Ctx> {
  * file.
  *
  * @example
- *   const checkpointStore = defineManagedResource<"checkpoint", RunId, CheckpointSaver, Ctx>({
- *     name: "checkpoint",
- *     acquire: (runId, ctx) =>
- *       new CheckpointSaver({ storage: ctx.storage, bucket: ctx.bucket, runId }),
- *     release: (saver) => saver.clear(),
- *   });
- *
- *   // In the machine:
- *   types: { …, sub: {} as ManagedResourceSub<"checkpoint", RunId> },
+ * ```ts
+ * import {
+ *   defineMachine,
+ *   defineManagedResource,
+ *   type Interpret,
+ *   type ManagedResourceSub,
+ *   type Reducer,
+ * } from "@demlik/tea";
+ * import { run } from "@demlik/tea/promise";
+ *
+ * type RunId = string;
+ * type State = { type: "idle" } | { type: "running"; runId: RunId };
+ * type Msg = { type: "start"; runId: RunId } | { type: "stop" };
+ * type Cmd = { type: "start_graph"; runId: RunId };
+ * interface Ctx { readonly storage: Storage; readonly bucket: string }
+ * declare class CheckpointSaver {
+ *   constructor(opts: { storage: Storage; bucket: string; runId: RunId });
+ *   save(step: string): Promise<void>;
+ *   clear(): Promise<void>;
+ * }
+ * declare const update: Reducer<State, Msg, Cmd>;
+ * declare const ctx: Ctx;
+ *
+ * const checkpointStore = defineManagedResource<"checkpoint", RunId, CheckpointSaver, Ctx>({
+ *   name: "checkpoint",
+ *   acquire: (runId, ctx) =>
+ *     new CheckpointSaver({ storage: ctx.storage, bucket: ctx.bucket, runId }),
+ *   release: (saver) => saver.clear(),
+ * });
+ *
+ * // In the machine:
+ * const machine = defineMachine({
+ *   types: {
+ *     model: {} as State,
+ *     msg: {} as Msg,
+ *     cmd: {} as Cmd,
+ *     sub: {} as ManagedResourceSub<"checkpoint", RunId>,
+ *     ctx: {} as Ctx,
+ *   },
+ *   init: (loaded) => [loaded ?? { type: "idle" }, []],
+ *   update,
  *   subs: [
  *     checkpointStore.depKeyed((s: State) =>
  *       s.type === "running" ? s.runId : null,
  *     ),
  *   ],
+ * });
  *
- *   // At run:
- *   run(machine, { interpret, subscribe: { checkpoint: checkpointStore.subscribe } });
- *
- *   // In interpret (read the live handle the reconciler holds):
- *   start_graph: async (cmd, ctx) => {
+ * // In interpret (read the live handle the reconciler holds):
+ * const interpret: Interpret<Msg, Cmd, Ctx> = {
+ *   start_graph: async (cmd) => {
  *     const saver = checkpointStore.get(cmd.runId);  // same owner, no rebuild
- *     ...
- *   }
+ *     await saver?.save("started");
+ *   },
+ * };
+ *
+ * // At run:
+ * run(machine, { ctx, interpret, subscribe: { checkpoint: checkpointStore.subscribe } });
+ * ```
  */
 declare function defineManagedResource<N extends string, TKey, Handle, Ctx>(opts: DefineManagedResourceOpts<N, TKey, Handle, Ctx>): ManagedResourceBattery<N, TKey, Handle, Ctx>;
 
@@ -588,28 +624,65 @@ interface TransportBattery<N extends string, TKey, Outbound, M, Ctx> {
  * Build the battery. One call per seam at the machine's host file.
  *
  * @example
- *   const handsSeam = fromTransport<"hands", RunId, HandsInbound, HandsOutbound, Msg, Ctx>({
- *     name: "hands",
- *     openTransport: (runId, ctx) => ctx.openHandsWs(runId),
- *     parseInbound: (raw) => parseHandsInbound(JSON.parse(raw)),
- *     onInbound: (inbound, runId) => ({ type: "hands_said", runId, inbound }),
- *     lostMsg: (runId) => ({ type: "hands_lost", runId }),
- *     serializeOutbound: (out) => JSON.stringify(out),
- *   });
- *
- *   // In the machine:
- *   types: { …, sub: {} as TransportSub<"hands", RunId> },
+ * ```ts
+ * import {
+ *   defineMachine,
+ *   fromTransport,
+ *   type Interpret,
+ *   type Reducer,
+ *   type Transport,
+ *   type TransportSub,
+ * } from "@demlik/tea";
+ * import { run } from "@demlik/tea/promise";
+ *
+ * type RunId = string;
+ * type HandsInbound = { kind: "said"; text: string };
+ * type HandsOutbound = { kind: "do"; action: string };
+ * type State = { type: "idle" } | { type: "auditing"; runId: RunId };
+ * type Msg =
+ *   | { type: "hands_said"; runId: RunId; inbound: HandsInbound }
+ *   | { type: "hands_lost"; runId: RunId };
+ * type Cmd = { type: "send_hands"; runId: RunId; outbound: HandsOutbound };
+ * interface Ctx { readonly openHandsWs: (runId: RunId) => Transport }
+ * declare function parseHandsInbound(json: unknown): HandsInbound | null;
+ * declare const update: Reducer<State, Msg, Cmd>;
+ * declare const ctx: Ctx;
+ *
+ * const handsSeam = fromTransport<"hands", RunId, HandsInbound, HandsOutbound, Msg, Ctx>({
+ *   name: "hands",
+ *   openTransport: (runId, ctx) => ctx.openHandsWs(runId),
+ *   parseInbound: (raw) => parseHandsInbound(JSON.parse(raw)),
+ *   onInbound: (inbound, runId) => ({ type: "hands_said", runId, inbound }),
+ *   lostMsg: (runId) => ({ type: "hands_lost", runId }),
+ *   serializeOutbound: (out) => JSON.stringify(out),
+ * });
+ *
+ * // In the machine:
+ * const machine = defineMachine({
+ *   types: {
+ *     model: {} as State,
+ *     msg: {} as Msg,
+ *     cmd: {} as Cmd,
+ *     sub: {} as TransportSub<"hands", RunId>,
+ *     ctx: {} as Ctx,
+ *   },
+ *   init: (loaded) => [loaded ?? { type: "idle" }, []],
+ *   update,
  *   subs: [
  *     handsSeam.depKeyed((s: State) =>
  *       s.type === "auditing" ? s.runId : null,
  *     ),
  *   ],
+ * });
  *
- *   // At run:
- *   run(machine, { interpret, subscribe: { hands: handsSeam.subscribe } });
- *
- *   // In interpret:
+ * // In interpret:
+ * const interpret: Interpret<Msg, Cmd, Ctx> = {
  *   send_hands: async (cmd) => { handsSeam.send(cmd.runId, cmd.outbound); },
+ * };
+ *
+ * // At run:
+ * run(machine, { ctx, interpret, subscribe: { hands: handsSeam.subscribe } });
+ * ```
  */
 declare function fromTransport<N extends string, TKey, Inbound, Outbound, M, Ctx>(opts: FromTransportOpts<N, TKey, Inbound, Outbound, M, Ctx>): TransportBattery<N, TKey, Outbound, M, Ctx>;
 

package/dist/index.js

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

package/dist/jev/index.d.ts

@@ -1,13 +1,13 @@
-import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState, b as ResilientTimerMsg } from '../index-q1PoukOZ.js';
-import { l as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, n as DepKeyedSub, p as TimerSub } from '../core-rDbOaJTN.js';
+import { R as RunCmd, F as FailMsg, S as SucceedMsg, a as ResilientState, b as ResilientTimerMsg } from '../index-2kNxy6az.js';
+import { O as Outcome, b as CmdDef, T as TimerDeps, C as Cmd, l as DepKeyedSub, m as TimerSub } from '../core-Ce9ncpuv.js';
 import { RetryPolicy } from '../retry-backoff/index.js';
-import { D as DeadlineExceeded, a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, f as CacheEvictMsg } from '../index-DaX_P35Q.js';
-import { S as SubscribeHandler } from '../types-DPm5YCDQ.js';
-import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-Cberb5Rr.js';
-import { F as FanOutState } from '../index-Cx0F2M34.js';
+import { D as DeadlineExceeded, a as DeadlineSub, T as TtlCache, C as CacheEvictionSub, c as CacheEvictMsg } from '../index-e36uEyl4.js';
+import { S as SubscribeHandler } from '../types-SzNSHKlV.js';
+import { B as BatchWindow, a as BatchWindowSub, b as BatchWindowExpired } from '../index-Bf9_bNql.js';
+import { F as FanOutState } from '../index-Ce5GYAuI.js';
 import '@standard-schema/spec';
-import '../index-CcrKLtse.js';
-import '../runtime-types-B62Ucnxr.js';
+import '../index-DWdg7R1l.js';
+import '../runtime-types-BKg2CGMx.js';
 
 /**
  * @packageDocumentation

package/dist/jev/index.js

@@ -1,14 +1,13 @@
-import { createBatchWindow } from '../chunk-DFUEAA6L.js';
+import { createBatchWindow } from '../chunk-PQSDUX6B.js';
 import '../chunk-LFZUK6J2.js';
-import { describeError } from '../chunk-G5E74IJB.js';
 import { createFanOut } from '../chunk-QNGYQMZB.js';
-import '../chunk-TXN2KFHF.js';
-import { runCmdDef, createResilientCall } from '../chunk-6XBEYZME.js';
+import { runCmdDef, createResilientCall } from '../chunk-WTSOW2MD.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-C3G2QFEZ.js';
 import '../chunk-VBDU4JL6.js';
 import '../chunk-4LPY67E4.js';
-import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-GWWCCSDH.js';
-import { liftSlice, readInOrder } from '../chunk-C4U5D5HP.js';
-import { Outcome } from '../chunk-K4ETBNKS.js';
+import '../chunk-TXN2KFHF.js';
+import { liftSlice, readInOrder } from '../chunk-FNGZMVIT.js';
+import { describeError, Outcome } from '../chunk-AIIXV4XB.js';
 
 // src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;