@demlik/tea 0.12.0 → 0.14.0

package/dist/circuit-breaker/index.d.ts

@@ -1,197 +0,0 @@
-/**
- * @packageDocumentation
- * @demlik/tea/circuit-breaker — per-target failure tracking as pure state + ops.
- *
- * Same shape as `@demlik/tea/work-queue`'s `ops.ts`, `@demlik/tea/rate-limit`,
- * and `@demlik/tea/idempotency`: 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 breaker 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 state value and never mutates its input (invariant 1 —
- * state is a value, not a place). `canPass` returns a `[next, allowed]` tuple so
- * the caller branches on the decision while threading the advanced state forward
- * — same convention as `rate-limit`'s `tryConsume` / `record`. `onSuccess` /
- * `onFailure` are the outcome-recording transitions the caller folds in once the
- * guarded call resolves.
- *
- * ## The phase machine
- *
- * A circuit breaker guards a fallible downstream target (an HTTP backend, a DB,
- * a flaky tool call). Instead of hammering a target that is already failing, it
- * trips OPEN after enough failures and fast-fails subsequent calls for a
- * cooldown, then probes with a few trial calls before fully closing again.
- * Three phases, each carrying ONLY its own data so impossible states are
- * unrepresentable (pattern 11):
- *
- *   - **closed** — the healthy steady state. Calls pass through. Carries
- *     `failures`: the count of *consecutive* failures since the last success.
- *     A success resets it to 0; the `failureThreshold`-th failure trips the
- *     breaker OPEN. Only `closed` has a failure counter — `open` and
- *     `half_open` don't, because in those phases the count is irrelevant
- *     (the breaker has already tripped / is already probing).
- *
- *   - **open** — the tripped state. All calls fast-fail (no downstream load).
- *     Carries `openedAtMs`: the clock reading at which the breaker tripped.
- *     `canPass` compares `nowMs - openedAtMs` against `cooldownMs` to decide
- *     when to start probing. Only `open` carries a timestamp — neither other
- *     phase is timing anything.
- *
- *   - **half_open** — the probing state. A limited number of trial calls are
- *     allowed through to test whether the target has recovered. Carries
- *     `probes`: the count of probes admitted so far this probing round.
- *     `canPass` admits while `probes < halfOpenMaxProbes`, then fast-fails the
- *     rest (so a slow target can't be flooded by every queued caller at once).
- *     A probe success closes the breaker; a probe failure re-opens it (and
- *     resets the cooldown clock). Only `half_open` counts in-flight probes.
- *
- * ### Transition table
- *
- * Rows are the current phase; columns are the event. `→` denotes the next
- * phase; `self` means unchanged. `nowMs` is the injected clock.
- *
- * | from \ event | onSuccess      | onFailure                              | canPass (→ allowed?)                                                                 |
- * | ------------ | -------------- | -------------------------------------- | ------------------------------------------------------------------------------------ |
- * | closed       | closed(0)      | failures+1; trip → open(nowMs) at thr. | self → true (always)                                                                  |
- * | open         | self *(¹)*     | self                                   | elapsed ≥ cooldown → half_open(1), true; else self → false                            |
- * | half_open    | → closed(0)    | → open(nowMs) (probe failed)           | probes < max → half_open(probes+1), true; else self → false                          |
- *
- * *(¹)* `onSuccess` on `open` "shouldn't happen": no call was admitted while
- * open, so no success can be reported for one. We leave the state unchanged
- * rather than throw — the breaker is a coordination aid, not a correctness
- * gate, and a spurious success report (e.g. a late-arriving result from before
- * the trip) must not silently un-trip the breaker. `onFailure` on `open` is
- * likewise a no-op: the breaker is already tripped; the `open` clock is anchored
- * at the trip, not bumped by late failures.
- *
- * ### The probe-admission asymmetry
- *
- * Entering `half_open` happens inside `canPass`, not `onSuccess` / `onFailure`,
- * because the cooldown is a *time* condition and only `canPass` reads the clock
- * against `openedAtMs`. The first `canPass` after the cooldown elapses both
- * transitions the phase AND admits the probe (`[half_open(1), true]`) — one
- * caller drives the recovery attempt. Subsequent `canPass` calls in the same
- * round admit up to `halfOpenMaxProbes` total, then fast-fail until a probe
- * resolves and `onSuccess` / `onFailure` moves the phase out of `half_open`.
- *
- * This module is a textbook three-state machine — a clean `/machine-viz` demo.
- *
- * NOT exported from the package root — reached via the
- * `@demlik/tea/circuit-breaker` subpath, same one-shape-per-package rule as
- * `work-queue`, `rate-limit`, and `idempotency`.
- */
-/**
- * Circuit-breaker policy — pure configuration, no mutable state. One policy is
- * shared across all the calls guarded by one logical breaker (often a
- * module-scope const). `CircuitState` carries the mutable counts; this carries
- * the thresholds those counts are compared against.
- */
-interface CircuitPolicy {
-    /**
-     * Consecutive failures in `closed` that trip the breaker `open`. The
-     * `failureThreshold`-th failure is the one that trips — with a threshold of
-     * 5, the breaker survives 4 failures and opens on the 5th.
-     */
-    readonly failureThreshold: number;
-    /**
-     * How long the breaker stays `open` before `canPass` starts admitting
-     * probes, in milliseconds. Measured from `openedAtMs`; the cutoff is
-     * half-open (`elapsed >= cooldownMs` admits), matching `rate-limit` /
-     * `idempotency` window edges — a breaker opened at `t` first probes at
-     * `t + cooldownMs`.
-     */
-    readonly cooldownMs: number;
-    /**
-     * How many probe calls `half_open` admits before fast-failing the rest of
-     * the round. Caps the load on a recovering target — a single slow probe
-     * can't be joined by every queued caller. The round ends when a probe
-     * resolves: success closes the breaker, failure re-opens it.
-     */
-    readonly halfOpenMaxProbes: number;
-}
-/**
- * Sensible defaults: trip after 5 consecutive failures, cool down for 30s,
- * admit a single probe before deciding. Tuned for guarding a network backend;
- * override per call site rather than mutating this shared const.
- */
-declare const defaultCircuitPolicy: CircuitPolicy;
-/**
- * The breaker's phase. A discriminated union on `phase` so each phase carries
- * ONLY its own data and impossible combinations are unrepresentable (pattern
- * 11): there is no state with both a failure count AND an open timestamp,
- * because such a state is meaningless. `phase` is the discriminant; every field
- * is `readonly` so the whole value is trivially JSON-serializable into a
- * consumer's `Store<S>` and safe to thread through a pure reducer.
- *
- *   - `closed`    carries `failures`   — consecutive failures since last success.
- *   - `open`      carries `openedAtMs` — clock reading when it tripped.
- *   - `half_open` carries `probes`     — probes admitted this round.
- */
-type CircuitState = {
-    readonly phase: "closed";
-    readonly failures: number;
-} | {
-    readonly phase: "open";
-    readonly openedAtMs: number;
-} | {
-    readonly phase: "half_open";
-    readonly probes: number;
-};
-/** The starting state: closed with zero recorded failures. */
-declare function initCircuit(): CircuitState;
-/**
- * Record a successful guarded call. PURE — returns a new state; the input is
- * never mutated.
- *
- *   - `closed`    → reset `failures` to 0 (a success breaks the consecutive run).
- *   - `half_open` → the probe succeeded; the target has recovered → `closed`.
- *   - `open`      → unchanged. A success "shouldn't happen" while open (no call
- *                   was admitted to produce one); a late/spurious success must
- *                   not silently un-trip the breaker. See module header note ¹.
- */
-declare function onSuccess(state: CircuitState, _policy: CircuitPolicy): CircuitState;
-/**
- * Record a failed guarded call. PURE — returns a new state; the input is never
- * mutated. `nowMs` is the injected clock, stamped onto the `open` phase when the
- * breaker trips so `canPass` can measure the cooldown later.
- *
- *   - `closed`    → `failures + 1`; if that reaches `failureThreshold`, trip to
- *                   `open(nowMs)`. The threshold-th failure is the one that trips.
- *   - `half_open` → the probe failed; the target is still unhealthy →
- *                   `open(nowMs)`, restarting the cooldown clock so a fresh
- *                   cooldown elapses before the next probe round.
- *   - `open`      → unchanged. The breaker is already tripped; the `open` clock
- *                   is anchored at the original trip, not bumped by late
- *                   failures. See module header note ¹.
- */
-declare function onFailure(state: CircuitState, policy: CircuitPolicy, nowMs: number): CircuitState;
-/**
- * Decide whether a call may pass, advancing the phase as a side effect of the
- * decision. PURE — returns `[next, allowed]`; the input is never mutated.
- * Branch on the boolean, thread the state forward regardless:
- *
- *   const [c1, allowed] = canPass(state.circuit, policy, nowMs);
- *   if (!allowed) return [{ ...state, circuit: c1 }, [fastFailCmd]];
- *   return [{ ...state, circuit: c1 }, [doGuardedCallCmd]];
- *
- *   - `closed`    → `[state, true]` — always passes; failures are recorded by
- *                   `onFailure` once the call resolves, not gated here.
- *   - `open`      → if `nowMs - openedAtMs >= cooldownMs` the cooldown has
- *                   elapsed → enter `half_open` and admit this caller as the
- *                   first probe: `[half_open(1), true]`. Otherwise still cooling
- *                   down → `[state, false]` (fast-fail, no downstream load).
- *   - `half_open` → admit while `probes < halfOpenMaxProbes`, incrementing the
- *                   count: `[half_open(probes+1), true]`. Once the cap is hit →
- *                   `[state, false]` until a probe resolves and `onSuccess` /
- *                   `onFailure` moves the phase out of `half_open`.
- *
- * Entering `half_open` lives here (not in `onSuccess` / `onFailure`) because the
- * cooldown is a time condition and only `canPass` reads `nowMs` against
- * `openedAtMs`. See the module header's probe-admission note.
- */
-declare function canPass(state: CircuitState, policy: CircuitPolicy, nowMs: number): readonly [CircuitState, boolean];
-
-export { type CircuitPolicy, type CircuitState, canPass, defaultCircuitPolicy, initCircuit, onFailure, onSuccess };

package/dist/circuit-breaker/index.js

@@ -1,3 +0,0 @@
-export { canPass, defaultCircuitPolicy, initCircuit, onFailure, onSuccess } from '../chunk-UF4MZSLT.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/circuit-breaker/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/core-Bjc0bS8j.d.ts

@@ -1,326 +0,0 @@
-type SyncReturn<S, C extends Cmd> = readonly [S, readonly C[]] & {
-    readonly then?: never;
-};
-type UpdateForm = "reducer" | "transitions";
-declare function detectUpdateForm(update: object): UpdateForm;
-declare function formOf(machine: {
-    update: object;
-    __form?: UpdateForm;
-}): UpdateForm;
-declare class NoCellError extends Error {
-    readonly msgType: string;
-    readonly stateName: string;
-    readonly name = "NoCellError";
-    readonly _tag: "NoCellError";
-    constructor(msgType: string, stateName: string);
-}
-declare function applyCell<S, M extends {
-    type: string;
-}, C extends Cmd>(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, state: S, msg: M): readonly [S, readonly C[]];
-declare function applyCellChecked<S, M extends {
-    type: string;
-}, C extends Cmd>(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, state: S, msg: M): readonly [S, readonly C[]];
-declare function msgKeysOf(machine: {
-    update: object;
-    __form?: UpdateForm;
-}): readonly string[];
-type MachineShape = {
-    readonly form: "reducer";
-    /** Every `Msg.type` the flat reducer has a cell for. */
-    readonly msgs: readonly string[];
-} | {
-    readonly form: "transitions";
-    /** The union of every row's `Msg.type` keys (see `msgKeysOf`). */
-    readonly msgs: readonly string[];
-    /** Every `state.type` the table has a row for, in table order. */
-    readonly states: readonly string[];
-    /** `state.type` → the `Msg.type`s that state has a cell for. */
-    readonly accepts: Readonly<Record<string, readonly string[]>>;
-};
-declare function describeMachine(machine: {
-    update: object;
-    __form?: UpdateForm;
-}): MachineShape;
-declare function acceptsOf(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, stateType: string): readonly string[];
-type Reducer<S, M extends {
-    type: string;
-}, C extends Cmd> = {
-    [K in M["type"]]: (state: S, msg: Extract<M, {
-        type: K;
-    }>) => SyncReturn<S, C>;
-};
-type Transitions<S extends {
-    type: string;
-}, M extends {
-    type: string;
-}, C extends Cmd> = {
-    [P in S["type"]]: {
-        [K in M["type"]]: (state: Extract<S, {
-            type: P;
-        }>, msg: Extract<M, {
-            type: K;
-        }>) => SyncReturn<S, C>;
-    };
-};
-type Cmd<T extends string = string> = {
-    readonly type: T;
-};
-declare const Cmd: {
-    /**
-     * The empty Cmd array. Typed `readonly never[]` so it's assignable to any
-     * `readonly C[]` for any `C extends Cmd`. Use in `init` returns and
-     * Transitions cells that emit zero effects:
-     *
-     *   init: (loaded) => [loaded ?? initial, Cmd.none],
-     *   tick: (state) => [state, Cmd.none],
-     *
-     * Elm's `Cmd.none` analogue. Cultural signal alongside the runtime help:
-     * `[state, Cmd.none]` reads as intent ("this transition emits nothing"),
-     * `[state, []]` reads as "empty array of what".
-     *
-     * Frozen at runtime so a downstream consumer can't `.push()` into the
-     * shared reference.
-     */
-    readonly none: readonly never[];
-    /**
-     * Flat concat of cmd arrays. Use when a cell composes effects from
-     * multiple conditional sources:
-     *
-     *   return [next, Cmd.batch(
-     *     Cmd.whenDefined(state.queueItemId, (id) => ({ type: "complete", id })),
-     *     Cmd.when(state.windowId !== undefined, { type: "close_window", windowId }),
-     *     [{ type: "detach_debugger", tabId: state.tabId }],
-     *   )];
-     *
-     * `<const C>` keeps inline cmd literals' discriminants narrow (same
-     * rationale as `when` / `whenDefined` above).
-     */
-    readonly batch: <const C extends Cmd>(...arrs: readonly (readonly C[])[]) => readonly C[];
-    /**
-     * Emit `cmd` wrapped in a single-element array iff `cond` is true.
-     * Otherwise return the empty array. Spreads cleanly into the cmds array
-     * returned by a Transitions cell.
-     *
-     * `const C` (TypeScript 5.0+) keeps the inferred `type:` discriminator
-     * literal narrow when called with an object literal — so `Cmd.when(b,
-     * { type: "x", ... })` infers as `{ type: "x", ... }`, not `{ type:
-     * string, ... }`, and stays assignable to a discriminated-union arm
-     * without `as const` at the call site.
-     */
-    readonly when: <const C extends Cmd>(cond: boolean, cmd: C) => readonly C[];
-    /**
-     * If `value` is defined, call `build(value)` and emit the resulting cmd
-     * wrapped in a single-element array. If `value` is `undefined`, return
-     * the empty array. `value` is narrowed to `T` inside `build`.
-     *
-     * `const C` on the return type keeps the callback's object-literal
-     * `type:` field narrow (see `when` above for the full rationale).
-     */
-    readonly whenDefined: <T, const C extends Cmd>(value: T | undefined, build: (value: T) => C) => readonly C[];
-};
-type SubId = string & {
-    readonly __brand: "SubId";
-};
-/**
- * Construct a `SubId` from a string. Use this everywhere a Sub literal is
- * built — including ids derived from runtime data (`subId(\`ws:${auditId}\`)`).
- * The brand is structural, not nominal, so dynamic ids are permitted; the
- * constructor's job is to make the identity decision explicit at every call
- * site so the type system can catch accidental raw-string drift.
- *
- * Strengthens invariant 7 (identity is explicit).
- */
-declare function subId(s: string): SubId;
-type Sub<T extends string = string> = {
-    readonly id: SubId;
-    readonly type: T;
-};
-type Dispose = () => void | Promise<void>;
-declare function structuralHash(deps: unknown): string;
-interface DepKeyedSub<S, M, Ctx = unknown> {
-    /**
-     * The slice of state this Sub depends on. `null` OR `undefined` ⇒ the Sub is
-     * inactive in this state (the substrate disposes it if it was running) — see
-     * `depsInactive`, so `(s) => s.optionalRunId` gates correctly. Otherwise the
-     * Sub is active, keyed on `structuralHash(deps)`.
-     *
-     * Pure (invariant 2). Plain JSON-compatible data only (invariant 1) — the
-     * structural hash walks it deterministically and THROWS on a `Date`, `Map`,
-     * `Set`, `Error` or class instance rather than collapsing them all onto one
-     * id. Project such a value first (`startedAt.toISOString()`).
-     */
-    readonly deps: (state: S) => unknown;
-    /**
-     * Open the resource for the current `state` (whose `deps` the kernel just
-     * found non-null). Receives `dispatch` to fire follow-up Msgs (a timer's
-     * fire, an inbound frame) and the machine's `ctx` (the host's transport
-     * factory, storage handles). Returns the `Dispose` the substrate runs on
-     * teardown / re-arm. Same role as a `subscribe[type]` handler's returned
-     * cleanup.
-     *
-     * `source` takes `state` (not the deps slice) so the slice type `D` never
-     * escapes the entry — each battery's `.depKeyed` closes over its own typed
-     * deps internally (cast-free existential: the entry that produced the deps
-     * is the entry that consumes them).
-     */
-    readonly source: (state: S, dispatch: (msg: M) => void, ctx: Ctx) => Dispose;
-}
-interface Identity<S, M> {
-    /** The identity THIS instance owns. Pure (invariant 2); plain value. */
-    readonly ofState: (state: S) => unknown;
-    /**
-     * The identity a message is addressed to, or `undefined` when the message
-     * carries no identity (lifecycle / pre-identity messages — never dropped).
-     * Pure (invariant 2); plain value when defined.
-     */
-    readonly ofMsg: (msg: M) => unknown;
-}
-interface Port<T> {
-    readonly __brand: "port";
-    readonly name: string;
-    readonly __t?: T;
-}
-/**
- * Augmentation injected onto `ctx` inside Cmd handlers. Handlers receive
- * `ctx & PortEmitter` so they can call `ctx.emit(port, value)` synchronously.
- * Subscribers registered via `runtime.subscribePort(port, listener)` receive
- * the value immediately.
- *
- * Emitting to a port with no subscribers is a no-op (does not throw).
- */
-interface PortEmitter {
-    emit<T>(port: Port<T>, value: T): void;
-}
-type NoCtx = Readonly<Record<never, never>>;
-/**
- * Spelled-out alias for `NoCtx`.
- *
- * @deprecated Use {@link NoCtx}. One Way to Do Each Thing — `NoCtx` is the
- * single non-deprecated name for the context-free-ctx marker (this alias has
- * no in-tree uses). Kept as a re-export for one minor per the deprecate-don't-
- * delete policy in `MAINTAINING.md`, then removed.
- */
-type ContextFree = NoCtx;
-type Interpret<M extends {
-    type: string;
-}, C extends Cmd, Ctx> = {
-    [K in C["type"]]: (cmd: Extract<C, {
-        type: K;
-    }>, ctx: Ctx & PortEmitter, dispatch?: (msg: M) => void) => Promise<M | void>;
-};
-type InterpretDetached<C extends Cmd, Allowed extends {
-    type: string;
-}, Ctx> = (cmd: C, ctx: Ctx & PortEmitter, dispatch: (msg: Allowed) => void) => Promise<void>;
-type Subscribe<M extends {
-    type: string;
-}, U extends Sub, Ctx> = {
-    [K in U["type"]]: (sub: Extract<U, {
-        type: K;
-    }>, ctx: Ctx, dispatch: (msg: M) => void) => Dispose;
-};
-type Machine<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx> = {
-    /**
-     * Boot the runtime. Called once by `run(...)` with whatever `Store.load()`
-     * returned: `null` on fresh boot, the persisted state on rehydrate.
-     *
-     * **Contract:** when `loaded !== null`, init MUST return `[loaded, []]` —
-     * no Cmds. Init's rehydrate branch is the migration / parse boundary, not
-     * the boot-effect hook. See Invariant 2 in `.patterns/tea/tea-invariants.md`.
-     *
-     * Boot effects routes:
-     *   - Stateless infrastructure → host module top, outside TEA.
-     *   - State-conditional resume → a `boot` Msg the host dispatches once
-     *     after `run(...)` returns.
-     *
-     * Violations are caught at runtime by `replay` (which throws with a
-     * pointer to the alternatives).
-     */
-    init: (loaded: S | null, ctx: Ctx) => readonly [S, readonly C[]];
-    update: Reducer<S, M, C> | ([S] extends [{
-        type: string;
-    }] ? Transitions<S, M, C> : never);
-    /**
-     * Dep-keyed Subs. Each declares the state slice it depends on; the substrate
-     * derives the id (`structuralHash(deps)`) and the gate (`deps` non-null) and
-     * folds them into the SAME reconcile loop `subscriptions` feeds. The author
-     * never writes `subId(...)` and never lists Subs in a central
-     * `subscriptions(state)` aggregate — a per-Sub gate travels with the Sub, so
-     * a new phase can't silently forget to arm it.
-     *
-     * The deps slice type is erased to `unknown` per entry — each Sub's slice
-     * differs, but the slice type never crosses this field (the kernel only needs
-     * to hash it and pass `state` back to that same entry's `source`).
-     *
-     * Optional and independent of `subscriptions` / `subscribe`: a machine that
-     * omits `subs` reconciles exactly as before.
-     *
-     * Strengthens invariant 4 (lifecycle owned by the substrate) and invariant 7
-     * (identity derived, not hand-authored).
-     */
-    subs?: ReadonlyArray<DepKeyedSub<S, M, Ctx>>;
-    /**
-     * Instance-identity filter. Declares THIS instance's identity once; the
-     * substrate drops any message addressed to a DIFFERENT identity before it
-     * reaches `update`. Replaces the per-cell `if (msg.runId !== state.runId)`
-     * guard entirely — the reducer never sees a foreign-instance message, so no
-     * cell needs to check.
-     *
-     * Opt-in: a machine that omits `identity` skips the filter (every message
-     * reaches `update`, exactly as before). A message whose `ofMsg` returns
-     * `undefined` is identity-agnostic and always reaches `update` (lifecycle /
-     * pre-identity messages).
-     *
-     * Strengthens invariant 7 (identity is explicit — declared once, enforced by
-     * the substrate) and invariant 6 (mis-addressed messages dropped at one
-     * observable point, not per cell).
-     */
-    identity?: Identity<S, M>;
-    /**
-     * Manual Sub aggregate — the documented escape hatch, KEPT alongside `subs`.
-     * The machine that needs cross-Sub logic the per-Sub `deps` fold can't
-     * express lists Subs here; the substrate reconciles them via `subscribe`.
-     * Both paths feed ONE reconcile pass.
-     */
-    subscriptions?: (state: S) => readonly U[];
-    subscribe?: Subscribe<M, U, Ctx>;
-    /**
-     * The update form ("reducer" | "transitions"), stamped non-enumerably by
-     * `defineMachine` at construction (see `UpdateForm` / `formOf`). Optional in
-     * the type so the structural `Machine` annotation form keeps accepting plain
-     * object literals; readers go through `formOf`, which falls back to
-     * `detectUpdateForm` when the tag is absent. Never written by hand.
-     */
-    readonly __form?: UpdateForm;
-} & ([C] extends [Cmd<never>] ? {
-    interpret?: Interpret<M, C, Ctx>;
-} : {
-    interpret: Interpret<M, C, Ctx>;
-}) & ([U] extends [Sub<never>] ? unknown : {
-    subscriptions: (state: S) => readonly U[];
-    subscribe: Subscribe<M, U, Ctx>;
-});
-declare function foldUpdates<S, M extends {
-    type: string;
-}, C extends Cmd>(machine: {
-    update: object;
-    __form?: UpdateForm;
-}, initialState: S, msgs: readonly M[]): {
-    state: S;
-    cmds: C[];
-};
-declare function foldMsgs<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, base: S, msgs: readonly M[]): S;
-
-export { Cmd as C, type DepKeyedSub as D, type Interpret as I, type Machine as M, NoCellError as N, type PortEmitter as P, type Reducer as R, type Sub as S, type Transitions as T, type UpdateForm as U, type Port as a, type SubId as b, type InterpretDetached as c, type ContextFree as d, type Dispose as e, type Identity as f, type MachineShape as g, type NoCtx as h, type Subscribe as i, type SyncReturn as j, acceptsOf as k, applyCell as l, applyCellChecked as m, describeMachine as n, detectUpdateForm as o, foldMsgs as p, foldUpdates as q, formOf as r, msgKeysOf as s, structuralHash as t, subId as u };

package/dist/deadline/index.js

@@ -1,6 +0,0 @@
-export { deadlineExceeded, deadlineSub, setTimeoutArmTimer, subscribeDeadline, subscribeWith } from '../chunk-JGVL3WPL.js';
-import '../chunk-2YFLOCWX.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/deadline/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/debounce/index.js

@@ -1,3 +0,0 @@
-export { debounce } from '../chunk-J6527VRQ.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/debounce/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/extension/react.d.ts

@@ -1,121 +0,0 @@
-import { ReactNode } from 'react';
-
-/**
- * React adapters for the background TEA runtime.
- *
- * Two layers, both built on the same `bridgeClient`:
- *
- *   1. `useBackgroundRuntime(opts)` — direct hook. One bridge client per
- *      call. Surfaces that only have a single consumer mount it inline.
- *
- *   2. `createBackgroundRuntimeContext<S, M>()` → `{ Provider, useDispatch,
- *      useState, useRuntime }` — factory-style React context. Mounts the
- *      bridge client ONCE inside the Provider; child hooks read `state` /
- *      `dispatch` from context. Surfaces that drill `dispatch` through
- *      multiple component layers, or mount `useBackgroundRuntime` more
- *      than once for the same channel, should use this instead.
- *
- * Why a factory (not a single global context):
- *   - Type safety: each app types it against its own `S` / `M`.
- *   - Tests can mount fresh contexts per test (no module-level state to
- *     reset).
- *   - Multiple-runtimes case: an app COULD theoretically have two
- *     background-shaped runtimes (e.g. one per channel); the factory
- *     pattern doesn't preclude it.
- *
- * Hook lifecycle (`useBackgroundRuntime`) — preserved from the prior
- * single-export module:
- *   1. `useSyncExternalStore` subscribes to broadcasts via
- *      `bridgeClient.subscribe`, reading the latest state via
- *      `bridgeClient.getSnapshot`. Reference stability is owned by the
- *      bridge — `getSnapshot` returns the SAME `S` until a new broadcast
- *      overwrites it, so React doesn't loop.
- *   2. A one-shot `hydrate()` call seeds `latestState` before the first
- *      broadcast arrives. The hydrate side-effect runs in an effect so the
- *      first render shows `null` and the subsequent render flips to the
- *      hydrated snapshot (or stays null if the host is still booting).
- *   3. `dispatch(msg)` sends `:dispatch` envelopes.
- *
- * On unmount: `useSyncExternalStore` removes the listener; the host's
- * bridge stays installed.
- *
- * Canon §3.1: React adapters use `useSyncExternalStore`, not
- * `useState + useEffect`. `useMachine` and `useRuntime` already follow this
- * — `useBackgroundRuntime` (and by extension the Provider) does too. One
- * Way to Do Each Thing.
- *
- * NOTE: This is a separate entry from the main `index.ts` so apps that
- * never need React don't drag react into their type graph. The React
- * adapter peer-depends on react (you must have it installed in the app).
- */
-
-interface UseBackgroundRuntimeOpts<S> {
-    channel: string;
-    /**
-     * REQUIRED parse for inbound `state` payloads. Forwarded to
-     * `bridgeClient` — see `BridgeClientOpts.parseState`. Surfaces own this
-     * because the chrome.runtime boundary is `unknown` (Inv 8). Returning
-     * `null` drops the payload silently.
-     */
-    parseState: (raw: unknown) => S | null;
-}
-interface UseBackgroundRuntimeResult<S, M> {
-    /** Latest snapshot from the host. `null` until the first hydrate response
-     * or the first broadcast arrives. Surfaces SHOULD render a placeholder
-     * for the null window. */
-    state: S | null;
-    /** Send a msg to the host runtime. Resolves once the host's dispatch
-     * settles. */
-    dispatch(msg: M): Promise<void>;
-}
-declare function useBackgroundRuntime<S, M extends {
-    type: string;
-}>({ channel, parseState, }: UseBackgroundRuntimeOpts<S>): UseBackgroundRuntimeResult<S, M>;
-interface BackgroundRuntimeContext<S, M> {
-    /**
-     * Wrap a subtree to share a single background-runtime bridge client.
-     * `opts` is forwarded verbatim to `useBackgroundRuntime` — same channel,
-     * same parse contract.
-     */
-    Provider: (props: {
-        opts: UseBackgroundRuntimeOpts<S>;
-        children: ReactNode;
-    }) => ReactNode;
-    /**
-     * Returns the dispatch function bound to this Provider's bridge client.
-     * Reference is stable across renders (per `useBackgroundRuntime`'s
-     * `useCallback`), so passing it to memoized children won't churn them.
-     */
-    useDispatch: () => (msg: M) => Promise<void>;
-    /**
-     * Returns a slice of the latest state. `selector` defaults to identity
-     * (returns the whole `S | null` snapshot). Selectors run on every state
-     * change — surfaces with expensive transforms should memoize the
-     * selector at call site.
-     *
-     * Returns `null` until the first hydrate / broadcast lands when the
-     * selector is identity; for non-identity selectors the return type is
-     * `T` and the caller's selector decides how to handle the pre-hydrate
-     * `null` snapshot.
-     */
-    useState: {
-        (): S | null;
-        <T>(selector: (state: S | null) => T): T;
-    };
-    /**
-     * Escape hatch — returns the full `{ state, dispatch }` pair as-is.
-     * Useful for consumers that want both the snapshot and the dispatch
-     * fn in a single hook call (e.g. effects that read state THEN
-     * dispatch in response).
-     *
-     * Not a `@demlik/tea` `Runtime<S, M>` — the bridge surface is a thinner
-     * client. This hook returns the same shape as `useBackgroundRuntime`,
-     * just sourced from context instead of mounting a fresh client.
-     */
-    useRuntime: () => UseBackgroundRuntimeResult<S, M>;
-}
-declare function createBackgroundRuntimeContext<S, M extends {
-    type: string;
-}>(): BackgroundRuntimeContext<S, M>;
-
-export { type BackgroundRuntimeContext, type UseBackgroundRuntimeOpts, type UseBackgroundRuntimeResult, createBackgroundRuntimeContext, useBackgroundRuntime };