@demlik/tea 0.13.0 → 0.14.0

package/dist/runtime-types-CNLmhWif.d.ts

@@ -1,517 +0,0 @@
-import { Result } from 'better-result';
-import { a as Port, N as NoCellError, C as Cmd, c as Reducer, A as AnyCmdDef, S as Sub, M as Machine, d as Settled, e as CmdOf, T as Transitions, f as NeedsOf, P as PortEmitter, O as OkOf, E as ErrOf, U as UpdateForm, g as InterpretDetached } from './core-Co0LWkIA.js';
-
-/**
- * @demlik/tea runtime interface surface + pure helpers — the public types,
- * interfaces, and construction/composition helpers the runtime (`./run`)
- * implements against: `Store`, the error-sink and supervision contracts, the
- * `RuntimeRef` / `BootingRuntime` / `Runtime` handle hierarchy, `definePort`, the
- * identity-typed constructors `defineMachine` / `asReducer`, and the pure tools
- * `replay` (compose without running) and `tryInterpret` (Railway).
- */
-
-declare const ReducerBrand: unique symbol;
-type Branded<T> = T & {
-    readonly [ReducerBrand]: true;
-};
-/**
- * Compile-time exhaustiveness assertion for default branches of switches over
- * discriminated unions narrowed by hand (Sub handlers, message-bridge
- * dispatchers, port fanouts) — TS narrows the operand to `never` only if every
- * variant is covered, so adding one produces a compile error at the `absurd(x)`
- * site. Strengthens invariant 7 (identity is explicit).
- *
- * @example
- *   switch (msg.type) {
- *     case "a": return ...;
- *     case "b": return ...;
- *     default: return absurd(msg);  // compile error if a "c" is added
- *   }
- */
-declare function absurd(x: never): never;
-declare const noop: <S, M, C extends Cmd>(state: S, _msg: M) => readonly [S, readonly C[]];
-/**
- * Thrown by `definePort` when a name has already been registered in the current
- * process. Symmetric with `SubIdCollisionError` (thrown by `reconcileSubs`) —
- * both mechanize invariant 7 (identity is explicit) at the runtime layer the
- * type system cannot reach (string names compared at runtime).
- */
-declare class PortNameCollisionError extends Error {
-    readonly name = "PortNameCollisionError";
-    readonly _tag: "PortNameCollisionError";
-    constructor(portName: string);
-}
-/**
- * Thrown by `reconcileSubs` when, within ONE desired subscription set, two subs
- * share an `id` but declare different `type`s — a silent bug class the type
- * system cannot reach (ids are strings compared at runtime). The symmetric twin
- * of `PortNameCollisionError`: both mechanize invariant 7 (identity is explicit)
- * at the runtime layer. Same id across transitions is the no-churn case and does
- * NOT throw; only a within-set type conflict does.
- */
-declare class SubIdCollisionError extends Error {
-    readonly name = "SubIdCollisionError";
-    readonly _tag: "SubIdCollisionError";
-    constructor(id: string, declaredType: string, conflictingType: string);
-}
-/**
- * Test-only escape hatch — clears the module-level port-name registry so the
- * collision assert in `definePort` doesn't false-positive across vitest's
- * non-isolated runs. Production code MUST NOT call this.
- *
- * @internal test-only
- */
-declare function __resetPortRegistry(): void;
-/**
- * Which otherwise-unattributable runtime path produced an error. Every fanout is
- * throw-isolated so one bad consumer never strands its siblings, and the
- * isolated throw routes to the `OnError` sink rather than a bare `console.error`.
- *
- * - `"follow-up"` — a follow-up Msg an interpret handler returned rejected when
- *   re-dispatched (the original dispatcher already resolved, so no caller).
- *   A rejection caused by `stop()`'s own teardown is NOT this phase — see
- *   `"discard"`.
- * - `"stop-save"` — the final `store.save(state)` inside `stop()` threw
- *   (`stop()` resolves regardless, so without the sink this was silent loss).
- * - `"reduce"` — the pure `update` (reducer) threw synchronously; the configured
- *   `Supervision` strategy decides what happens next, but the throw is surfaced
- *   here as data first.
- * - `"listener"` — a `runtime.subscribe(...)` listener threw during fanout.
- * - `"observer"` — a `runtime.observe(...)` observer threw during fanout.
- * - `"event"` — the `events` projector or an `on(type, ...)` handler threw.
- * - `"boot"` — an `onBoot` handler threw (boot fanout, or a late registration).
- * - `"port-emit"` — a `subscribePort` listener threw during a port emission.
- * - `"sub-cleanup"` — a subscription's cleanup threw (reconcile-removal or
- *   `stop()` teardown).
- * - `"discard"` — work lost to a teardown the host asked for. Two witnesses,
- *   both carrying a `RuntimeDiscardNotice`: `stop()` was called while interpret
- *   handlers were still awaiting (`RuntimeDiscardedError`), and a Msg that
- *   arrived DURING `stop()`'s drain and so could not be delivered
- *   (`DispatchDiscardedError`), and teardown work that did not settle inside
- *   `disposeTimeoutMs` (`DisposeTimeoutNotice`). The one phase that is a
- *   LIFECYCLE report rather than a failure: legal, merely lossy.
- * - `"identity-drop"` — the `Identity` filter dropped a message addressed to a
- *   different instance (`IdentityDropNotice`). Its own phase rather than
- *   `"discard"`: the loss is the FILTER WORKING, not a teardown, and a host
- *   routing it (a metric, a 409 back to the caller) wants it apart from
- *   unmount-time noise. Warn-only, like every `RuntimeDiscardNotice`.
- *
- * The phase never decides fatality — the ERROR CLASS does (`RuntimeDiscardNotice`
- * warns, everything else rethrows). A phase is attached by the report site, so a
- * consumer sink that throws while handling a `"discard"` report inherits that
- * phase; keying the warn-only path on it would make the sink's own defect vanish.
- */
-type RuntimeErrorPhase = "follow-up" | "stop-save" | "reduce" | "listener" | "observer" | "event" | "boot" | "port-emit" | "sub-cleanup" | "discard" | "identity-drop";
-/** Context handed to an `OnError` sink alongside the error itself. */
-interface RuntimeErrorContext {
-    readonly phase: RuntimeErrorPhase;
-}
-/**
- * Sink for runtime failures that have no caller to reject at. Configured via
- * `run(machine, { onError })`. Should be total — a throw inside the sink is
- * itself surfaced via the default sink, so it can never re-introduce a silent
- * failure.
- */
-type OnError = (error: unknown, context: RuntimeErrorContext) => void;
-/** The three declared reducer-throw supervision strategies. */
-type SupervisionStrategy = "stop" | "escalate" | "restart";
-/**
- * Declared supervision policy for a reducer (`update`) throw, at
- * `run(machine, { supervision })`. The bare-string shorthands (`"stop"` /
- * `"escalate"`) are accepted for the two strategies that need no host data;
- * `restart` MUST be the object form because it carries the `rehydrate` callback,
- * which MUST return a valid `S` synchronously (the reducer is synchronous, so
- * recovery is too — no suspension across the single-writer slot).
- */
-type Supervision<S, M extends {
-    type: string;
-}> = "stop" | "escalate" | {
-    readonly strategy: "stop";
-} | {
-    readonly strategy: "escalate";
-} | {
-    readonly strategy: "restart";
-    /**
-     * Host-provided rehydration to last-known-good state. Invoked when the
-     * reducer throws; its return value becomes the new state and the transition
-     * continues from there. Receives the pre-throw `state`, the `msg` that
-     * triggered the throw, and the thrown `error` so the host can route by
-     * cause.
-     */
-    readonly rehydrate: (state: S, msg: M, error: unknown) => S;
-};
-/**
- * Raised by `idle()` when the quiescence wait hits its iteration cap without the
- * dispatch tail stabilizing — `idle()` REJECTS rather than silently resolving,
- * so a livelocking machine surfaces instead of masquerading as quiescent.
- * Mechanizes invariant 6 at the runtime layer, the role `PortNameCollisionError`
- * plays for invariant 7.
- */
-declare class QuiescenceTimeoutError extends Error {
-    readonly iterations: number;
-    readonly name = "QuiescenceTimeoutError";
-    readonly _tag: "QuiescenceTimeoutError";
-    constructor(iterations: number);
-}
-/**
- * Base of the LOSSY-BUT-LEGAL teardown facts: work the host discarded by letting
- * go of a runtime that still had something outstanding. Reported under
- * `phase: "discard"`, never raised.
- *
- * It exists so "is this fatal?" has ONE definition — `error instanceof
- * RuntimeDiscardNotice` — that the default sink can ask about any error from any
- * site. The phase cannot answer it: a report site attaches the phase, so a
- * consumer sink that throws while handling a `"discard"` report carries that
- * phase into the sink-failure path, and a phase-keyed warn branch would swallow
- * the sink's own defect. Sub-classing is how a new teardown fact opts into the
- * warn-only treatment; nothing else can.
- */
-declare abstract class RuntimeDiscardNotice extends Error {
-}
-/**
- * Reported to the `OnError` sink under `phase: "discard"` when `stop()` is
- * called while `interpret` handlers are still awaiting. The host is dropping
- * its only handle on that work: `stop()` drains the tail, but the listeners,
- * observers and event handlers that would have consumed the resulting
- * transitions are gone, so the Cmds' results reach nobody.
- *
- * The motivating shape is `@demlik/tea/react`'s `useMachine`, which memoizes on
- * `[machine, ctx, store]` — a ctx re-derived mid-flight replaces the runtime,
- * and the in-flight mutation's response arrives for a runtime the UI no longer
- * renders, silently rewinding the visible state. Never a throw: tearing a
- * runtime down mid-flight is legal (a navigation does it every time), so this
- * is surfaced as data, not raised. Mechanizes invariant 6 (no silent failures)
- * at the teardown seam, the role `QuiescenceTimeoutError` plays for `idle()`.
- */
-declare class RuntimeDiscardedError extends RuntimeDiscardNotice {
-    readonly pendingCmds: number;
-    readonly name = "RuntimeDiscardedError";
-    readonly _tag: "RuntimeDiscardedError";
-    constructor(pendingCmds: number);
-}
-/**
- * Reported to the `OnError` sink under `phase: "identity-drop"` when the
- * `Identity` filter drops a message addressed to a different instance.
- *
- * The drop itself is the feature — it is what lets a reducer stop repeating
- * `if (msg.runId !== state.runId) return`. What was missing is that it was
- * INVISIBLE: the dispatch resolved exactly like an applied one, so a reusable
- * Durable Object serving run A and then run B lost every run-B message and
- * reported success to each caller. The comment claiming "the one observable
- * enforcement point" described this notice before it existed.
- *
- * Never fatal (`RuntimeDiscardNotice`): a mis-addressed message is a normal
- * consequence of instance reuse, not a defect. A host that wants to act on it
- * — a metric, a 409 to the caller, a re-route — reads `phase: "identity-drop"`
- * in its own sink.
- */
-declare class IdentityDropNotice extends RuntimeDiscardNotice {
-    readonly msgType: string;
-    readonly name = "IdentityDropNotice";
-    readonly _tag: "IdentityDropNotice";
-    constructor(msgType: string);
-}
-/**
- * Reported to the `OnError` sink under `phase: "discard"` when `stop()`'s wait
- * for async teardown work hits `disposeTimeoutMs`.
- *
- * `stop()` awaits the disposals it started so `await runtime.stop()` can mean
- * "safe to evict". A `release` that never settles must not turn that guarantee
- * into a host that never shuts down, so the wait is bounded and expiry is
- * REPORTED rather than silently tolerated — the resource is genuinely still
- * open at that point, and only the host can decide what that costs.
- */
-declare class DisposeTimeoutNotice extends RuntimeDiscardNotice {
-    readonly pendingDisposals: number;
-    readonly timeoutMs: number;
-    readonly name = "DisposeTimeoutNotice";
-    readonly _tag: "DisposeTimeoutNotice";
-    constructor(pendingDisposals: number, timeoutMs: number);
-}
-/**
- * The rejection of a dispatch that arrived DURING `stop()`'s drain — an in-flight
- * interpret handler's follow-up Msg, a detached handler's terminal Msg, or a Sub
- * that is still live because subs are torn down only after the drain. The stop
- * barrier is absolute (the Msg is refused, never folded), so this names the loss.
- *
- * It is the SECOND witness of `RuntimeDiscardedError`'s fact, and it is why the
- * drain window is a distinct runtime state rather than a plain `stopped` flag:
- * a Msg refused inside the window was discarded BY the teardown, while the same
- * refusal after `stop()` has returned is a consumer dispatching into a runtime it
- * already retired — a real error, and still loud (`phase: "follow-up"`, or the
- * caller's own rejection). The distinction is the state at refusal time, never
- * the message text.
- */
-declare class DispatchDiscardedError extends RuntimeDiscardNotice {
-    readonly msgType: string;
-    readonly name = "DispatchDiscardedError";
-    readonly _tag: "DispatchDiscardedError";
-    constructor(msgType: string);
-}
-/**
- * Define a typed port. `name` is metadata (devtools / debug logs); port identity
- * is by reference. Each definePort call must use a unique `name` — a second call
- * with the same name throws `PortNameCollisionError`. Use ports for "data leaving
- * the runtime selectively" (cursor announcements, DOM-mutation broadcasts,
- * telemetry) that should NOT be folded into State. Strengthens invariant 7.
- */
-declare function definePort<T>(name: string): Port<T>;
-interface Store<S> {
-    load(): Promise<unknown>;
-    save(state: S): Promise<void>;
-    migrate(raw: unknown): S | null;
-}
-interface Schema<S> {
-    safeParse(raw: unknown): {
-        success: true;
-        data: S;
-    } | {
-        success: false;
-    };
-}
-/**
- * Build a `Store.migrate` from a schema (job 1) and an optional thin `upcast`
- * (job 2). `upcast` maps a recognized-but-OLD raw shape forward into the shape
- * the schema validates; it defaults to identity (no version migration yet).
- *
- * Never throws — a shape the schema rejects returns `null`, the substrate's
- * fresh-boot path, per the `Store.migrate` contract. An `upcast` that itself
- * throws on a corrupt blob is caught and collapses to `null` (same posture).
- */
-declare function schemaMigrate<S>(schema: Schema<S>, upcast?: (raw: unknown) => unknown): (raw: unknown) => S | null;
-type DispatchSettle = "quiescent" | "once";
-interface RuntimeRef<M extends {
-    type: string;
-}> {
-    /**
-     * Put a Msg in the runtime's inbox and resolve once processed. Runs to
-     * QUIESCENCE by default: settles only after the dispatched Msg AND every
-     * transitive interpret follow-up has drained. Pass `{ settle: "once" }` (or
-     * call `dispatchOnce`) for the single-step case.
-     *
-     * Rejection ordering: the ONE dispatched transition's own failure surfaces
-     * first, here. If it succeeds but the follow-up chain never stabilizes, the
-     * quiescent drain rejects with `QuiescenceTimeoutError`. Follow-up Msg
-     * rejections themselves route to the `onError` sink, never here.
-     */
-    dispatch(msg: M, opts?: {
-        readonly settle?: DispatchSettle;
-    }): Promise<void>;
-    /**
-     * Dispatch `msg` and resolve after exactly ONE transition's effects settle,
-     * WITHOUT draining the follow-up chain — equivalent to
-     * `dispatch(msg, { settle: "once" })`. Prefer plain `dispatch` unless you will
-     * `await runtime.idle()` yourself; the un-awaited follow-up chain is the
-     * footgun the quiescent default removed.
-     */
-    dispatchOnce(msg: M): Promise<void>;
-}
-interface BootingRuntime<S, M extends {
-    type: string;
-}, E extends {
-    type: string;
-} = never> extends RuntimeRef<M> {
-    dispatch(msg: M, opts?: {
-        readonly settle?: DispatchSettle;
-    }): Promise<void>;
-    dispatchOnce(msg: M): Promise<void>;
-    subscribe(listener: () => void): () => void;
-    observe(observer: (msg: M, state: S) => void): () => void;
-    /**
-     * Subscribe to the INITIAL State — the boot transition. Fires exactly once:
-     * immediately if boot already completed (so a late subscriber never misses
-     * it), otherwise on the boot fanout. Returns a cleanup (a no-op once fired).
-     */
-    onBoot(handler: (state: S) => void): () => void;
-    /**
-     * Subscribe to a SEMANTIC event of `type`. The handler receives exactly the
-     * `E` member whose `type` matches `K`, so a consumer never touches another
-     * event's shape and never references the machine's PRIVATE Msg names. Multiple
-     * handlers per type; fanout is synchronous and throw-isolated. Fires only when
-     * the machine's `events` projector (wired on `run`) emits that type.
-     */
-    on<K extends E["type"]>(type: K, handler: (event: Extract<E, {
-        type: K;
-    }>) => void): () => void;
-    /**
-     * Subscribe to a typed Port. Multiple listeners per port; fanout is synchronous
-     * and isolated. Ports are for "data leaving the runtime selectively" (see
-     * `definePort`) — distinct from `observe` (every transition) and State.
-     */
-    subscribePort<T>(port: Port<T>, listener: (value: T) => void): () => void;
-    /**
-     * Emit a value on a Port from OUTSIDE an interpret handler — same synchronous
-     * fanout as `ctx.emit`. The canonical use is `observe`-driven emission (one
-     * runtime publishing a state-derived signal another subscribes to via
-     * `subscribePort`) without spawning a "tell the outside world" Cmd per
-     * transition.
-     */
-    emitPort<T>(port: Port<T>, value: T): void;
-    /**
-     * Resolves to the booted `Runtime<S, M>` after boot completes (or rejects with
-     * the boot error). This is the ONLY way to obtain a `Runtime` — and a
-     * `Runtime` is the only handle whose `getState()` is total. Awaiting `ready` is
-     * the single gate between "boot in flight" and "State exists":
-     *
-     * ```ts
-     * const runtime = await run(machine, opts).ready;
-     * runtime.getState(); // total — never throws-before-boot
-     * ```
-     *
-     * Idempotent — the same settled promise, resolving to the same `Runtime`, comes
-     * back on every read. Expresses canon §2.3 (boot is a named, awaitable moment).
-     */
-    ready: Promise<Runtime<S, M, E>>;
-    stop(): Promise<void>;
-}
-interface Runtime<S, M extends {
-    type: string;
-}, E extends {
-    type: string;
-} = never> extends BootingRuntime<S, M, E> {
-    /**
-     * The current State. TOTAL — never throws. Obtaining a `Runtime` requires
-     * awaiting `ready`, which only resolves AFTER boot has run `init` and set the
-     * initial State.
-     */
-    getState(): S;
-    /** Resolves to this same `Runtime` once boot completes. Idempotent. */
-    ready: Promise<Runtime<S, M, E>>;
-    /**
-     * Resolves once the runtime has reached QUIESCENCE — every dispatched Msg AND
-     * every transitive interpret follow-up has been processed, with no further step
-     * pending on the tail. Since plain `dispatch` already runs to quiescence, this
-     * is mainly for follow-ups left by a `dispatchOnce` single step, or a chain
-     * kicked off by a Sub / boot `init` cmds with no `dispatch` to await.
-     *
-     * Idempotent and re-entrant-safe. Tail rejections are NOT surfaced here (a
-     * failing dispatch surfaces on its OWN promise; follow-up rejections route to
-     * `onError`). The one rejection `idle()` produces is `QuiescenceTimeoutError`
-     * on hitting the iteration cap — so a livelock stays distinguishable from a
-     * genuine quiesce (invariant 6). A poll is still correct when waiting on an
-     * EXTERNAL event the runtime cannot enqueue itself.
-     */
-    idle(): Promise<void>;
-    /**
-     * The terminal State of the run, or `undefined` while in flight — "terminal"
-     * per the `terminal` predicate passed to `run()` (no predicate → never
-     * terminal → always `undefined`). The first-class result read: the run's
-     * product off the State the machine already owns, NOT scraped off the `observe`
-     * firehose by matching an internal Msg name. Total — never throws.
-     */
-    result(): S | undefined;
-    /**
-     * Resolves with the terminal State the first time the run reaches one (per the
-     * `terminal` predicate). If ALREADY terminal, resolves immediately; otherwise
-     * on the transition that first makes `terminal` hold. The awaitable companion
-     * to `result()`. With no predicate this never resolves. Idempotent and
-     * multi-caller safe.
-     */
-    done(): Promise<S>;
-}
-declare function defineMachine<S, M extends {
-    type: string;
-}, D extends AnyCmdDef, U extends Sub, Ctx>(m: Omit<Machine<S, M | Settled<D>, CmdOf<D>, U, Ctx>, "update" | "cmds"> & {
-    readonly cmds: readonly D[];
-    update: [S] extends [{
-        type: string;
-    }] ? Transitions<S, M | Settled<D>, CmdOf<D>> : never;
-}): Machine<S, M | Settled<D>, CmdOf<D>, U, Ctx>;
-declare function defineMachine<S, M extends {
-    type: string;
-}, D extends AnyCmdDef, U extends Sub, Ctx>(m: Omit<Machine<S, M | Settled<D>, CmdOf<D>, U, Ctx>, "update" | "cmds"> & {
-    readonly cmds: readonly D[];
-    update: Reducer<S, M | Settled<D>, CmdOf<D>>;
-}): Machine<S, M | Settled<D>, CmdOf<D>, U, Ctx>;
-declare function defineMachine<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(m: Omit<Machine<S, M, C, U, Ctx>, "update"> & {
-    update: [S] extends [{
-        type: string;
-    }] ? Transitions<S, M, C> : never;
-}): Machine<S, M, C, U, Ctx>;
-declare function defineMachine<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(m: Omit<Machine<S, M, C, U, Ctx>, "update"> & {
-    update: Reducer<S, M, C>;
-}): Machine<S, M, C, U, Ctx>;
-declare function asReducer<S, M extends {
-    type: string;
-}, C extends Cmd>(reducer: Reducer<S, M, C>): Branded<Reducer<S, M, C>>;
-type CtxArg<Ctx> = [Record<never, never>] extends [Ctx] ? {
-    ctx?: Ctx;
-} : {
-    ctx: Ctx;
-};
-declare function replay<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, opts: {
-    msgs: readonly M[];
-    ctx: Ctx;
-    loaded?: S | null;
-}): {
-    state: S;
-    cmds: C[];
-    subs: U[];
-    depSubs: {
-        index: number;
-        id: string;
-    }[];
-};
-declare function wrapDetached<C extends Cmd, M extends {
-    type: string;
-}, Allowed extends M, Ctx>(handler: InterpretDetached<C, Allowed, Ctx>): (cmd: C, ctx: Ctx & PortEmitter, dispatch?: (msg: M) => void) => Promise<void>;
-/**
- * `applyCell` with the missing-cell case in the return type.
- *
- * `Ok` carries the cell's `[nextState, cmds]` verbatim; `Err` carries the same
- * `NoCellError` (msg.type + state name) `applyCell` would have thrown. Dispatch
- * inside `run` keeps using the throwing `applyCell` — this is for callers that
- * step a machine themselves.
- */
-declare function tryApplyCell<S, M extends {
-    type: string;
-}, C extends Cmd>(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, state: S, msg: M): Result<readonly [S, readonly C[]], NoCellError>;
-/**
- * The refusal `tryFoldMsgs` reports: WHICH msg in the log had no cell, where.
- *
- * A plain record, not a new `Error` subclass — it is a `Result` payload, never
- * thrown, and the actual error is the existing `NoCellError` it carries. The
- * package's thrown-error idiom (`class extends Error` + `_tag`, pinned by
- * `error-idiom.test.ts`) applies to errors raised at the runtime edge; this one
- * is never raised, so adding a class would state a promise it does not make.
- */
-interface FoldRefusal<M> {
-    /** Index into the `msgs` array the fold was given. */
-    readonly index: number;
-    /** The offending Msg itself — so the caller can print it, not just point. */
-    readonly msg: M;
-    /** The underlying cell-lookup failure, carrying msg.type + state name. */
-    readonly error: NoCellError;
-}
-/**
- * `foldMsgs` with the missing-cell case in the return type, INCLUDING which
- * message failed.
- *
- * The motivating use is "this persisted log does not replay — tell the user
- * where". A bare `Result<S, NoCellError>` cannot: the error names the msg.type
- * and the state, but a log usually contains that type many times, so the
- * INDEX is the load-bearing fact. The fold stops at the first refusal (state
- * past that point is not defined) and returns it.
- *
- * Shares `foldMsgs`' dev-mode discipline: `deepFreeze` the input state,
- * `assertPureResult` the cell's return. Both compile out of production.
- */
-declare function tryFoldMsgs<S, M extends {
-    type: string;
-}, C extends Cmd>(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, base: S, msgs: readonly M[]): Result<S, FoldRefusal<M>>;
-declare function settle<D extends AnyCmdDef, Ctx>(def: D, work: (cmd: CmdOf<D>, ctx: Ctx & NeedsOf<CmdOf<D>> & PortEmitter) => Promise<Result<OkOf<D>, ErrOf<D>>>): (cmd: CmdOf<D>, ctx: Ctx & NeedsOf<CmdOf<D>> & PortEmitter) => Promise<Settled<D>>;
-declare function tryInterpret<C extends Cmd, Ok, M, Ctx>(work: (cmd: C, ctx: Ctx) => Promise<Ok>, onOk: (value: Ok, cmd: C) => M, onErr: (error: unknown, cmd: C) => M): (cmd: C, ctx: Ctx) => Promise<M>;
-
-export { type BootingRuntime as B, type CtxArg as C, DispatchDiscardedError as D, type FoldRefusal as F, IdentityDropNotice as I, type OnError as O, PortNameCollisionError as P, QuiescenceTimeoutError as Q, type Runtime as R, type Store as S, __resetPortRegistry as _, type Supervision as a, type Branded as b, type DispatchSettle as c, DisposeTimeoutNotice as d, RuntimeDiscardNotice as e, RuntimeDiscardedError as f, type RuntimeErrorContext as g, type RuntimeErrorPhase as h, type RuntimeRef as i, type Schema as j, SubIdCollisionError as k, type SupervisionStrategy as l, absurd as m, asReducer as n, defineMachine as o, definePort as p, noop as q, replay as r, schemaMigrate as s, settle as t, tryApplyCell as u, tryFoldMsgs as v, tryInterpret as w, wrapDetached as x };