@demlik/tea 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1,10 +1,73 @@
-import { B as BootingRuntime, a as ScopedCtxArg, S as Store, O as OnError, b as Supervision, R as Runtime } from './runtime-types-LWDoi943.js';
-export { c as Branded, C as CtxArg, D as DepToken, d as DepsOf, e as DispatchDiscardedError, f as DispatchSettle, g as DisposeTimeoutNotice, h as DriveFailedError, i as DriveStalledError, j as FencedRead, F as FencedStore, k as FoldRefusal, I as IdentityDropNotice, M as MachineTypes, l as OnReleaseError, P as PortNameCollisionError, m as ProvideFailedError, n as Provided, o as ProvidedCtx, p as Provider, q as ProviderCycleError, Q as QuiescenceTimeoutError, r as RuntimeDiscardNotice, s as RuntimeDiscardedError, t as RuntimeErrorContext, u as RuntimeErrorPhase, v as RuntimeRef, w as Schema, x as Scope, y as StoreConflictError, z as SubIdCollisionError, A as SupervisionStrategy, U as UnknownProviderError, _ as __resetPortRegistry, E as absurd, G as asReducer, H as defineMachine, J as definePort, K as dep, L as isFencedStore, N as isProvided, T as layer, V as noop, W as provide, X as replay, Y as schemaMigrate, Z as settle, $ as tryApplyCell, a0 as tryFoldMsgs, a1 as tryInterpret, a2 as value, a3 as wrapDetached } from './runtime-types-LWDoi943.js';
-import { C as Cmd, S as Sub, M as Machine, R as RequiredCtx, P as Port, D as Dispose, o as DepKeyedSub, c as SubId } from './core-CTzMJ82M.js';
-export { A as AnyCmdDef, b as CmdDef, p as CmdInput, a as CmdOf, i as CmdValue, E as ErrOf, q as ErrorsOf, r as ExhaustiveTransitions, s as Identity, I as Interpret, h as InterpretDetached, t as MachineShape, l as MalformedResult, N as NoCellError, k as NoCtx, O as OkOf, g as PortEmitter, d as Reducer, m as Requirements, f as RequirementsOf, e as Settled, u as SettledErr, v as SettledOk, w as Subscribe, x as SyncReturn, j as Tagged, n as TaggedError, T as Transitions, U as UpdateForm, y as acceptedTypes, z as acceptsOf, B as applyCell, F as applyCellChecked, G as describeMachine, H as detectUpdateForm, J as foldMsgs, K as foldUpdates, L as formOf, Q as msgKeysOf, V as structuralHash, W as subId } from './core-CTzMJ82M.js';
-import { S as SubscribeHandler } from './types-DP3f5NIl.js';
-import 'better-result';
-import 'zod';
+import { B as BootingRuntime, R as Runtime } from './runtime-types-CiVpC0HN.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-CiVpC0HN.js';
+import { C as Cmd, S as Sub, M as Machine, P as Port, o as DepKeyedSub, h as Dispose } from './core-BbgtiXdg.js';
+export { A as AnyCmdDef, w as AsyncSchemaError, a as BuiltinSub, B as BuiltinSubType, b as CmdDef, x as CmdInput, c as CmdOf, v as CmdValue, D as DeclaredErrorsOf, u as ErrOf, E as ErrorsOf, y as ExhaustiveTransitions, z as Identity, p as Interpret, F as InterpretArg, G as InterpretCell, I as InterpretDetached, H as MachineShape, r as MalformedResult, N as NoCellError, J as NoCtx, t as OkOf, O as OkOfCmd, l as Outcome, K as OutcomeContractError, L as OutcomeHelpers, m as PortEmitter, i as Reducer, R as RunHandlers, j as Settled, f as SettledErr, e as SettledOk, n as SubId, d as Subscribe, Q as SubscribeArg, V as SyncReturn, s as Tagged, g as TaggedError, T as TimerDeps, q as TimerSub, k as Transitions, X as UndeclaredFailureError, U as UpdateForm, W as Wired, Y as acceptedTypes, Z as acceptsOf, _ as applyCell, $ as applyCellChecked, a0 as describeMachine, a1 as detectUpdateForm, a2 as foldMsgs, a3 as foldUpdates, a4 as formOf, a5 as msgKeysOf, a6 as structuralHash, a7 as subId, a8 as subIdOf } from './core-BbgtiXdg.js';
+import { S as SubscribeHandler } from './types-LxZxGYda.js';
+import '@standard-schema/spec';
+
+/**
+ * @packageDocumentation
+ * The composition seam — the layer between a battery and a door.
+ *
+ * A battery is pure state plus verbs over that state. A door holds several
+ * batteries side by side in one Model. Everything between those two facts was,
+ * until now, hand-written at every consumer: the one-key record rebuild that
+ * threads a verb's `[slice, cmds]` result back into the host state, and the
+ * statement order that decides which slice wins a derived read.
+ *
+ * Two helpers cover it, and neither is an optics kit. {@link liftSlice} is the
+ * record rebuild with the key checked by the type system; {@link readInOrder}
+ * turns a read's precedence from statement order into a value you can name,
+ * export and assert on. ADR 0001 (no off-the-shelf resilience) and ADR 0014
+ * (Effect's types, never its runtime values) between them settle why this is
+ * forty lines here rather than a dependency.
+ *
+ * `docs/how-to/compose-two-battery-slices.md` wires both end to end over a
+ * two-battery door, and its `ts` blocks are compiled and run as
+ * `src/docs/how-to/compose-slices.test.ts`.
+ *
+ * Both are pure: no clock, no RNG, no storage, nothing captured. A `liftSlice`
+ * result is a fresh record and a Cmd array, so ADR 0014's journal/hash promise
+ * over a reducer's return value is untouched.
+ */
+/**
+ * Lift a battery verb's result into the host state that carries its slice.
+ *
+ * `liftSlice("resilience", state, knob.attempt(state.resilience, …))` is the
+ * `{ ...state, resilience: slice }` every consumer writes by hand, with the key
+ * checked: `key` must be a key of `S`, and the slice the verb returned must be
+ * assignable to the type that key carries — so naming the wrong field, or
+ * threading one battery's slice into another's key, is a compile error rather
+ * than a state shape nothing reads correctly.
+ *
+ * PURE — a fresh record and the verb's own Cmds, unchanged.
+ */
+declare function liftSlice<S, K extends keyof S, C>(key: K, state: S, [slice, cmds]: readonly [S[K], readonly C[]]): readonly [S, readonly C[]];
+/**
+ * One step of a composed read: the slice it consults, under the name that slice
+ * goes by. `read` returns `undefined` for "this slice has nothing to say",
+ * which is what hands the read on to the next step.
+ */
+interface ReadStep<In, Out> {
+    /** The slice this step consults — `"cache"`, `"failed"`, `"inFlight"`. */
+    readonly name: string;
+    /** What this slice says about `input`, or `undefined` to defer. */
+    readonly read: (input: In) => Out | undefined;
+}
+/**
+ * Run a composed read through `order` and return the first answer any step
+ * gives, or `absent` when every one defers.
+ *
+ * The point is that `order` is a VALUE. A derived read over three battery
+ * slices otherwise states its precedence as the order of three `if` statements,
+ * where it is invisible to the type system, unnameable in a test and one
+ * innocent-looking reshuffle away from being wrong — which is exactly the
+ * defect that escaped `classify-batch`'s per-battery test suites. Written as
+ * data, the precedence can be exported, printed and asserted on directly.
+ *
+ * PURE — it evaluates `read` in order and stores nothing.
+ */
+declare function readInOrder<In, Out>(input: In, order: readonly ReadStep<In, Out>[], absent: Out): Out;
 
 interface HistoryTracker<S, M extends {
     type: string;
@@ -181,177 +244,6 @@ declare function reconcile<S, M extends {
     type: string;
 }, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, authoritativeState: S, lastAppliedSeq: Ack | Seq, pending: readonly SeqTagged<M>[]): S;
 
-/**
- * @demlik/tea runtime — `run`: boot + the serial dispatch loop. The pure helpers
- * that compose against a machine without running it (`replay`, `tryInterpret`)
- * live in `./runtime-types`.
- */
-
-declare function run<S, M extends {
-    type: string;
-}, C extends Cmd, U extends Sub, Ctx, E extends {
-    type: string;
-} = never>(machine: Machine<S, M, C, U, Ctx>, opts: ScopedCtxArg<Ctx & RequiredCtx<C>> & {
-    store?: Store<S>;
-    onError?: OnError;
-    /**
-     * The clock that stamps `at` on a `Cmd.define`d effect's settled Msg at
-     * the interpret edge. Defaults to `Date.now`. Inject a fixed one for a
-     * deterministic run; a `replay` log carries its own `at`s and never reads
-     * this.
-     */
-    clock?: () => number;
-    /**
-     * The SEMANTIC event projector. Maps one APPLIED transition `(msg, state)`
-     * to zero-or-more public events of `E`; `[]` skips the transition. Maps the
-     * machine's PRIVATE Msg vocabulary to NAMED events — the private names never
-     * reach `on`'s `E` surface. Omit → `E = never` and `on` is uncallable. PURE.
-     */
-    events?: (msg: M, state: S) => readonly E[];
-    /**
-     * Declared policy for a reducer (`update`) throw. Always surfaced via
-     * `onError` (`phase: "reduce"`); the strategy decides what the runtime does
-     * next. Defaults to `"stop"`. See `Supervision`.
-     */
-    supervision?: Supervision<S, M>;
-    /**
-     * The run-terminality predicate — makes the run's outcome first-class. Fed to
-     * `Runtime.result()` and `Runtime.done()`. PURE. Omit → never terminal.
-     */
-    terminal?: (state: S) => boolean;
-    /**
-     * How long `stop()` waits for teardown work that returned a Promise (an
-     * async `release` in `defineManagedResource`, an async Sub cleanup) before
-     * giving up on it. Defaults to 5_000ms.
-     *
-     * `stop()` awaits those disposals so a host doing
-     * `await runtime.stop(); env.evict()` cannot drop the isolate mid-release —
-     * the leak the managed-resource battery exists to prevent, relocated to
-     * shutdown. The bound is what keeps a release that never settles from
-     * hanging the host: on expiry `stop()` reports a `DisposeTimeoutNotice`
-     * (warn-only, like every `RuntimeDiscardNotice`) and resolves anyway,
-     * because `stop()` resolving is a contract.
-     */
-    disposeTimeoutMs?: number;
-    /**
-     * Iteration cap for `idle()`'s quiescence wait. Defaults to 100_000. Test
-     * seam only. Production code must not set it.
-     *
-     * @internal test-only
-     */
-    __idleCap?: number;
-}): BootingRuntime<S, M, E>;
-/**
- * The outside-in stop, as a PAIR. A signal is only cancellation if something can
- * turn "aborted" into a transition this machine understands, and the kernel has
- * no built-in cancel Msg any more than it has a built-in terminal set — so the
- * `signal` and the `cancel` that reads it are one option, present together or
- * absent together. A discriminated union rather than two optional fields, on the
- * same reasoning as `AgentCompactionConfig`: a signal with no `cancel` is a stop
- * button wired to nothing, and that is a state worth making unrepresentable
- * rather than checking for.
- */
-type DriveCancellation<S, M> = {
-    readonly signal?: undefined;
-    readonly cancel?: undefined;
-} | {
-    /**
-     * Abort the run through this signal. On abort the drive dispatches
-     * `cancel`'s Msg and resolves on the State that lands — it does NOT reject,
-     * and a cancellation is never a `DriveFailedError`. Already aborted when
-     * the drive is called → the cancel Msg goes in place of `start`, so the
-     * run ends without the start's effects ever firing.
-     */
-    readonly signal: AbortSignal;
-    /**
-     * The Msg that settles this machine as cancelled, chosen off the current
-     * State exactly as `start` is. PURE. It must land a State `isTerminal`
-     * holds for — the drive resolves on the terminal predicate, not on the
-     * abort — and that State should be DURABLE, or a reload resumes the run
-     * its caller stopped.
-     */
-    readonly cancel: (state: S) => M;
-};
-/** Options for `driveToDone`. */
-type DriveToDoneOptions<S, M extends {
-    type: string;
-} = never> = DriveCancellation<S, M> & {
-    /**
-     * Marks a terminal State as a FAILURE. A State this holds for ends the drive
-     * like any terminal one — the runtime is stopped — but the drive REJECTS with
-     * `DriveFailedError` carrying it instead of resolving. A failed State is
-     * terminal by definition; it need not also satisfy `isTerminal`. Omit → the
-     * drive never rejects on State, only on a runtime error.
-     */
-    readonly failed?: (state: S) => boolean;
-};
-/**
- * Drive a machine from `start` to its terminal State in one call, then tear the
- * runtime down. The one-shot shape every "run this machine to done" test and
- * caller boundary otherwise hand-wires as six steps — `await ready`, `observe`,
- * park a promise, `dispatch(start)`, `getState()`, `stop()` — with the observer
- * leak and the forgotten `stop` those six steps invite.
- *
- * Takes the handle `run()` returns (a `Runtime` extends it, so a booted one is
- * accepted too), awaits `ready`, dispatches `start`, and resolves with the first
- * State for which `isTerminal` holds. A machine that boots already terminal (a
- * rehydrated finished run) resolves on its boot State and `start` is never
- * dispatched — a finished run has nothing to set in motion. `start` may be a
- * function of the boot State instead of a Msg: a machine rehydrated MID-run
- * needs its resume Msg, not its start Msg, and only the boot State says which
- * (the agent's `agent_boot` vs `agent_start` is the case in point). The
- * observer is detached and `stop()` awaited on EVERY exit: resolve, `failed`,
- * a stall, a boot or dispatch throw, the quiescence cap.
- *
- * Rejections are typed, never silent:
- *   - `DriveFailedError<S>` when `opts.failed` marks the final State — the State
- *     rides on `error.state`.
- *   - `DriveStalledError<S>` when `start`'s follow-up chain quiesces on a State
- *     that is neither terminal nor `failed` and the runtime has no live Sub and
- *     no Cmd in flight — nothing inside it can deliver another transition, so
- *     waiting would be a hang with the runtime leaked. The stalled State rides
- *     on `error.state`. A machine that CAN still move is not stalled: a live Sub
- *     (manual or dep-keyed) that delivers the terminal Msg after the dispatch
- *     quiesces keeps the drive waiting, and it resolves on that State. What the
- *     runtime cannot see — a dispatch from outside it after quiescence — does
- *     not count as live; a machine that depends on one declares it as a Sub.
- *   - `QuiescenceTimeoutError` when `start`'s follow-up chain never settles —
- *     the SAME cap `dispatch` and `idle()` already reject on (invariant 6), not a
- *     second clock. A livelocking machine surfaces as its own failure class.
- *   - the boot error, or whatever `dispatch(start)` rejects with, otherwise.
- *
- * `isTerminal` is caller-supplied, exactly as `run()`'s `terminal` option is —
- * the kernel has no built-in terminal-set concept and this does not add one.
- *
- * Cancellation is the same story: `{ signal, cancel }` stops the drive from
- * outside, and it settles the run rather than escaping it. On abort the drive
- * dispatches `cancel`'s Msg and RESOLVES on the terminal State that transition
- * lands — no rejection, no `DriveFailedError`, no `AbortError`. That is the whole
- * point of routing a stop through the Model: the outcome is durable, so a killed
- * process resumes reading a run that ended instead of restarting one someone
- * stopped. A cancel that THROWS is the one abort that rejects: it lands
- * no State, so its error is what the drive has to report — and that holds
- * whether the `cancel` function throws synchronously or the fold it produced
- * throws later, since both leave the run with no State to settle on. A State the
- * caller's `failed` predicate marks rejects on an abort exit exactly as it does
- * anywhere else. In-flight effects are not recalled — a promise cannot be cancelled —
- * so they settle to their own end and `stop()` drains them as it always did;
- * keeping their results off the public channels is the machine's own business.
- * Omit the pair and every path here behaves exactly as it did before.
- *
- * @param handle     the handle `run(machine, opts)` returned.
- * @param start      the Msg that sets the run in motion, or a function choosing
- *                   it off the boot State. PURE.
- * @param isTerminal the terminal predicate over the machine's State. PURE.
- * @param opts       an optional `failed` predicate and an optional
- *                   `{ signal, cancel }` pair (see {@link DriveToDoneOptions}).
- */
-declare function driveToDone<S, M extends {
-    type: string;
-}, E extends {
-    type: string;
-} = never>(handle: BootingRuntime<S, M, E>, start: M | ((booted: S) => M), isTerminal: (state: S) => boolean, opts?: DriveToDoneOptions<S, M>): Promise<S>;
-
 /**
  * The imperative listener target, expressed as the `add`/`remove` pair the
  * substrate pairs into a reconciled resource. Both halves receive the SAME
@@ -385,15 +277,16 @@ interface ListenerTarget<Args extends readonly unknown[], S extends Sub, Ctx> {
  * `Args`, `S`, `Ctx` are fixed when the target is defined — they describe the
  * one listener topology this factory owns (the platform arg tuple, which Sub
  * shape it filters on, what context resolves it). `M` is supplied at the
- * subscribe cell because the same listener feeds different Msgs in different
+ * runner because the same listener feeds different Msgs in different
  * machines. Pinning `S` here (rather than at the `msgFn` step) lets
- * `add`/`remove` read the concrete Sub's fields — `sub.alarmName`,
- * `sub.channel` — with NO cast at the substrate edge: the narrowing happens in
- * author-land where the Sub shape is in scope.
+ * `add`/`remove` read the concrete Sub's deps — `sub.deps.alarmName`,
+ * `sub.deps.channel` — with NO cast at the substrate edge: the narrowing
+ * happens in author-land where the Sub shape is in scope.
  *
  * The returned function is a `SubscribeHandler` factory in the exact shape of
  * every other Sub factory in `src/subs/`: supply the `msgFn` projection, get a
- * `(sub, ctx, dispatch) => cleanup` handler assignable to `machine.subscribe`.
+ * `(sub, ctx, dispatch) => cleanup` runner for the `subscribe` table `run`
+ * takes.
  * The cleanup the author NEVER writes is `() => remove(listener, sub, ctx)`,
  * with `listener` the identical reference passed to `add`.
  */
@@ -422,26 +315,26 @@ interface MinimalWebSocket {
 }
 
 type BroadcastSubData = {
-    channelName: string;
+    readonly channelName: string;
 };
-declare function fromBroadcastChannel<S extends Sub & BroadcastSubData, M>(msgFn: (event: MinimalMessageEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
+declare function fromBroadcastChannel<S extends Sub<string, BroadcastSubData>, M>(msgFn: (event: MinimalMessageEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
 
 type EventSourceSubData = {
-    url: string;
+    readonly url: string;
 };
 interface EventSourceFactoryOpts<S, M> {
     onMessage: (data: string, sub: S) => M | null;
     onError?: (event: MinimalEvent, sub: S) => M | null;
     onOpen?: (sub: S) => M | null;
 }
-declare function fromEventSource<S extends Sub & EventSourceSubData, M>(opts: EventSourceFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
+declare function fromEventSource<S extends Sub<string, EventSourceSubData>, M>(opts: EventSourceFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
 declare function fromEventTarget<S extends Sub, M>(getTarget: () => MinimalEventTarget, eventName: string, msgFn: (event: MinimalEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
 
 type IntervalSubData = {
-    intervalMs: number;
+    readonly intervalMs: number;
 };
-declare function fromInterval<S extends Sub & IntervalSubData, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
+declare function fromInterval<S extends Sub<string, IntervalSubData>, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
 
 declare function fromPort<S extends Sub, M, Ctx, T, RS = unknown, RM extends {
     type: string;
@@ -450,7 +343,7 @@ declare function fromPort<S extends Sub, M, Ctx, T, RS = unknown, RM extends {
 }>(selectRuntime: (ctx: Ctx) => Runtime<RS, RM>, port: Port<T>, msgFn: (value: T, sub: S) => M | null): SubscribeHandler<S, M, Ctx>;
 
 type WebSocketSubData = {
-    wsUrl: string;
+    readonly wsUrl: string;
 };
 interface WebSocketFactoryOpts<S, M> {
     onMessage: (data: unknown, sub: S) => M | null;
@@ -458,7 +351,7 @@ interface WebSocketFactoryOpts<S, M> {
     onError?: (event: MinimalEvent, sub: S) => M | null;
     onClose?: (code: number, reason: string, sub: S) => M | null;
 }
-declare function fromWebSocket<S extends Sub & WebSocketSubData, M>(opts: WebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
+declare function fromWebSocket<S extends Sub<string, WebSocketSubData>, M>(opts: WebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
 /** Cancels a scheduled reconnect timer (the inverse of `schedule`). */
 type CancelTimer = () => void;
@@ -482,97 +375,37 @@ interface ReconnectingWebSocketFactoryOpts<S, M> {
     /** Inject the timer (defaults to `setTimeout`/`clearTimeout`); the test seam. */
     schedule?: (fn: () => void, ms: number) => CancelTimer;
 }
-declare function fromReconnectingWebSocket<S extends Sub & WebSocketSubData, M>(opts: ReconnectingWebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
+declare function fromReconnectingWebSocket<S extends Sub<string, WebSocketSubData>, M>(opts: ReconnectingWebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
 
 type TimeoutSubData = {
-    delayMs: number;
+    readonly delayMs: number;
 };
-declare function fromTimeout<S extends Sub & TimeoutSubData, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
+declare function fromTimeout<S extends Sub<string, TimeoutSubData>, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
 
 /**
- * The Sub the battery builds. The consumer's `Sub` union includes
- * `ManagedResourceSub<TKey>` directly — the substrate reconciles by `id` and
- * `type` like any other Sub.
- */
-interface ManagedResourceSub<TKey> extends Sub<"managed_resource"> {
-    /** The lifetime key. Stable while the resource should be held; a change
-     *  retires the old resource (release) and acquires a fresh one. */
-    readonly key: TKey;
-}
-/**
- * A battery paired with a state-gate. Self-contained: it knows its `name`
- * (for the unique-name assert), how to derive its live Sub from a state
- * (`subFor`), how to handle its own `subscribe`, and whether it `owns` a given
- * Sub id.
- *
- * Generic in the consumer state `S`, the shared lifetime key `TKey`, and the
- * shared `Ctx`. `Handle` is the ONLY thing erased — each battery's handle type
- * differs (a checkpoint saver vs. a tool-call bridge) but never crosses this
- * interface, so a `combineManagedResources` array holds entries of
- * heterogeneous handle types with no cast. The sub type stays
- * `ManagedResourceSub<TKey>` end to end, so the substrate's narrowed Sub flows
- * straight in.
- */
-interface GatedManagedResource<S, TKey, Ctx> {
-    /** The owning battery's `name`. The combinator asserts these are unique. */
-    readonly name: string;
-    /**
-     * Derive this resource's live Sub for a given state: the battery's
-     * `.sub(key)` when `when(state)` returns a key, or `null` when it returns
-     * `null` (the resource should be torn down in that state).
-     */
-    readonly subFor: (state: S) => ManagedResourceSub<TKey> | null;
-    /**
-     * This battery's own `.subscribe`. The combinator routes an incoming
-     * `managed_resource` Sub to the entry whose `owns(sub)` is true, then calls
-     * this.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-    /**
-     * Does this entry own the given Sub? `sub.id === subIdFor(sub.key)` encodes
-     * the battery `name`, so a match is unambiguous.
-     */
-    readonly owns: (sub: ManagedResourceSub<TKey>) => boolean;
-}
-/**
- * What `combineManagedResources` returns: the single managed-resource
- * `subscribe` handler for the machine's `subscribe` record, and a `subs(state)`
- * builder for `subscriptions(state)`.
+ * The running Sub of a managed resource named `N`: its `deps` is the lifetime
+ * key. The consumer's Sub union (`types.sub`) includes it directly.
  */
-interface CombinedManagedResources<S, TKey, Ctx> {
-    /**
-     * Map every entry through its `when(state)`, drop the `null`s, and build the
-     * live Subs. Spread into `subscriptions(state)`. The derived list and the
-     * `subscribe` routing share one source — the entries — so they never drift.
-     */
-    readonly subs: (state: S) => ManagedResourceSub<TKey>[];
-    /**
-     * The SINGLE `subscribe.managed_resource` handler. Routes an incoming Sub to
-     * the owning battery by matching `sub.id === battery.subIdFor(sub.key)` (the
-     * id encodes the battery `name`). Throws loudly on an unrouted id — a wiring
-     * bug, never a silent no-op resource.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-}
-interface DefineManagedResourceOpts<TKey, Handle, Ctx> {
+type ManagedResourceSub<N extends string, TKey> = Sub<N, TKey>;
+interface DefineManagedResourceOpts<N extends string, TKey, Handle, Ctx> {
     /**
-     * A short, stable name. The Sub id is `managed:${name}:${stringify(key)}`,
-     * so two managed resources in one machine never collide and neither
-     * collides with a `fromTransport` Sub keyed on the same identity.
+     * A short, stable name — and the resource's Sub `type`. The machine's
+     * `subscribe` table holds this battery's runner under it, so it must be
+     * unique among the machine's Sub types.
      */
-    readonly name: string;
+    readonly name: N;
     /**
-     * Build the resource. Runs when the Sub appears in `subscriptions(state)`.
+     * Build the resource. Runs when the resource's `deps` turns non-null.
      * The returned Handle is the ONLY thing `release` receives — capture
-     * everything teardown needs into it. If `acquire` throws, the substrate's
-     * reconcile does NOT register the Sub and `release` is never called (no
-     * dangling half-built resource).
+     * everything teardown needs into it. If `acquire` throws, the engine does
+     * NOT register the Sub and `release` is never called (no dangling
+     * half-built resource).
      */
     readonly acquire: (key: TKey, ctx: Ctx) => Handle;
     /**
-     * Tear the resource down. Runs when the Sub leaves the desired set (phase
-     * exited) or when its key changes. MANDATORY — the guaranteed teardown is
-     * the reason this battery exists.
+     * Tear the resource down. Runs when the key goes null (phase exited) or
+     * changes. MANDATORY — the guaranteed teardown is the reason this battery
+     * exists.
      *
      * May be sync or async, and an async one is really awaited: the promise is
      * returned to the substrate, which tracks it and drains it inside `stop()`
@@ -586,78 +419,44 @@ interface DefineManagedResourceOpts<TKey, Handle, Ctx> {
     readonly release: (handle: Handle) => void | Promise<void>;
 }
 /**
- * What the battery returns: a `.sub(key)` builder for `subscriptions`, the
- * `.subscribe` handler for the machine's `subscribe` record, a `.get(key)`
- * accessor so Cmd handlers can reach the live Handle while the resource is
- * held, and a `.subIdFor(key)` for tests.
+ * What the battery returns: a `.depKeyed(when)` entry for the machine's
+ * `subs`, the `.subscribe` runner for the `subscribe` table handed to `run`,
+ * and a `.get(key)` accessor so Cmd handlers can reach the live Handle while
+ * the resource is held.
  */
-interface ManagedResourceBattery<TKey, Handle, Ctx> {
+interface ManagedResourceBattery<N extends string, TKey, Handle, Ctx> {
+    /** The battery's Sub type — its `name`. */
+    readonly type: N;
     /**
-     * Build the Sub for `subscriptions(state)`. The consumer calls this from
-     * inside their `subscriptions` cell for the phases where the resource
-     * should be live.
+     * The `subs` entry. `when(state)` returns the resource's KEY when it should
+     * be held, or `null` when it should be torn down. The key is the Sub's
+     * `deps`, so the engine derives the id from it: an unchanged key leaves the
+     * resource alone, a changed key releases the old one and acquires anew.
+     * Plain JSON-compatible data only — the id hash throws on anything else.
      */
-    readonly sub: (key: TKey) => ManagedResourceSub<TKey>;
+    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, ManagedResourceSub<N, TKey>>;
     /**
-     * Pair this battery with a state-gate, producing a self-contained entry for
-     * `combineManagedResources`. `when(state)` returns the resource's KEY when
-     * it should be live in that state, or `null` when it should be torn down.
-     *
-     * Folding "is it active?" and "what key?" into ONE declaration at the
-     * battery's own definition site is the point: a central `subscriptions(state)`
-     * list can silently forget to gate a new phase, but a per-resource gate
-     * travels with the resource. The combinator derives BOTH the active-sub list
-     * and the subscribe routing from these entries, so the two can never disagree.
-     *
-     * Generic in the consumer's state `S` (each `.gated` call binds its own `S`).
-     * The returned entry erases this battery's `Handle` — `combineManagedResources`
-     * holds entries of heterogeneous handle types with no cast — while keeping
-     * `TKey` and `Ctx` so the substrate's narrowed `ManagedResourceSub<TKey>`
-     * flows straight into the entry's `subscribe`.
+     * The runner for this battery's Sub type — hand it to `run` as
+     * `subscribe: { [battery.type]: battery.subscribe }`. Runs `acquire` on
+     * start, holds the Handle in the battery's handle table, and returns a
+     * cleanup that runs `release` (and forgets the Handle) on stop.
      */
-    readonly gated: <S>(when: (state: S) => TKey | null) => GatedManagedResource<S, TKey, Ctx>;
+    readonly subscribe: (sub: ManagedResourceSub<N, TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
     /**
-     * Dep-keyed entry for the machine's `subs` array. `when(state)` returns the
-     * resource's KEY when it should be held, or `null` when it should be torn
-     * down — the exact gate `.gated` takes, now producing a `DepKeyedSub` the
-     * kernel folds directly instead of an entry the `combineManagedResources`
-     * router multiplexes.
-     *
-     * This is the simplification the dep-keyed kernel unlocks: two managed
-     * resources used to COLLIDE on the single `subscribe.managed_resource` key
-     * (both subs share `type: "managed_resource"`), forcing
-     * `combineManagedResources` to route by SubId. A dep-keyed Sub has its OWN
-     * reconcile slot (its array position), so there is no shared `type` to route
-     * — each resource is one `subs` entry, no combinator, no router. `acquire` /
-     * `release` still ride the kernel's dispose-on-change / dispose-on-null
-     * reconcile, now via the dep-keyed source's `Dispose` instead of the
-     * `subscribe` cell's cleanup.
-     */
-    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, never, Ctx>;
-    /**
-     * The `subscribe.managed_resource` handler. Drop straight into the
-     * machine's `subscribe` record. Runs `acquire` on install, holds the
-     * Handle in the battery's handle table, and returns a cleanup that runs
-     * `release` (and forgets the Handle) on reconcile-out.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-    /**
-     * Accessor for the live Handle, keyed on `key`. Returns `undefined` when
-     * the resource is not currently held (no active sub for that key) — the
-     * caller decides whether that is an error. A Cmd handler wires its
-     * `ctx.getX(key)` through this, so the handler reads the SAME owner the
+     * Accessor for the live Handle, keyed on `key` (the author's key, never the
+     * derived Sub id). Returns `undefined` when the resource is not currently
+     * held — the caller decides whether that is an error. A Cmd handler wires
+     * its `ctx.getX(key)` through this, so the handler reads the SAME owner the
      * reconciler holds, never a hand-built duplicate.
      */
     readonly get: (key: TKey) => Handle | undefined;
-    /** Pre-derived subId for `(key)` — handy for tests. */
-    readonly subIdFor: (key: TKey) => SubId;
 }
 /**
  * Build the battery. One call per managed resource at the machine's host
  * file.
  *
  * @example
- *   const checkpointStore = defineManagedResource<RunId, CheckpointSaver, Ctx>({
+ *   const checkpointStore = defineManagedResource<"checkpoint", RunId, CheckpointSaver, Ctx>({
  *     name: "checkpoint",
  *     acquire: (runId, ctx) =>
  *       new CheckpointSaver({ storage: ctx.storage, bucket: ctx.bucket, runId }),
@@ -665,9 +464,15 @@ interface ManagedResourceBattery<TKey, Handle, Ctx> {
  *   });
  *
  *   // In the machine:
- *   subscriptions: (state) =>
- *     state.type === "running" ? [checkpointStore.sub(state.runId)] : [],
- *   subscribe: { managed_resource: checkpointStore.subscribe },
+ *   types: { …, sub: {} as ManagedResourceSub<"checkpoint", RunId> },
+ *   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) => {
@@ -675,8 +480,7 @@ interface ManagedResourceBattery<TKey, Handle, Ctx> {
  *     ...
  *   }
  */
-declare function defineManagedResource<TKey, Handle, Ctx>(opts: DefineManagedResourceOpts<TKey, Handle, Ctx>): ManagedResourceBattery<TKey, Handle, Ctx>;
-declare function combineManagedResources<S, TKey, Ctx>(entries: readonly GatedManagedResource<S, TKey, Ctx>[]): CombinedManagedResources<S, TKey, Ctx>;
+declare function defineManagedResource<N extends string, TKey, Handle, Ctx>(opts: DefineManagedResourceOpts<N, TKey, Handle, Ctx>): ManagedResourceBattery<N, TKey, Handle, Ctx>;
 
 /**
  * Duplex transport. The host (DO, worker thread, in-process bus) constructs
@@ -688,8 +492,8 @@ interface Transport {
     send(data: string): void;
     /**
      * Subscribe to inbound frames. Returns a cleanup that removes the listener.
-     * The battery wires this in its Sub's subscribe handler; cleanup runs when
-     * the phase exits (the substrate's reconcileSubs).
+     * The battery wires this in its runner; cleanup runs when the seam's key
+     * goes null or changes.
      */
     onMessage(listener: (data: string) => void): () => void;
     /**
@@ -702,26 +506,22 @@ interface Transport {
 }
 /**
  * Factory the consumer wires to a platform-specific transport. The battery
- * passes the runtime-derived key (`runId`, or whatever identity is on the
- * phase) so per-run transports can be addressed.
+ * passes the seam's key (`runId`, or whatever identity is on the phase) so
+ * per-run transports can be addressed.
  */
 type TransportFactory<K> = (key: K) => Transport;
 /**
- * The Sub the battery builds. The consumer's `Sub` union includes
- * `TransportSub<TKey>` directly — no wrapping needed, the substrate
- * reconciles by `id` and `type` like any other Sub.
+ * The running Sub of a seam named `N`: its `deps` is the seam key. The
+ * consumer's Sub union (`types.sub`) includes it directly.
  */
-interface TransportSub<TKey> extends Sub<"transport"> {
-    /** The phase / run identity. Stable for the lifetime of the seam. */
-    readonly key: TKey;
-}
-interface FromTransportOpts<TKey, Inbound, Outbound, M, Ctx> {
+type TransportSub<N extends string, TKey> = Sub<N, TKey>;
+interface FromTransportOpts<N extends string, TKey, Inbound, Outbound, M, Ctx> {
     /**
-     * A short, stable name for this seam. The Sub id is derived from
-     * `${name}:${stringify(key)}` so two seams in the same machine (e.g.
-     * `hands` + `worker`) never collide.
+     * A short, stable name for this seam — and its Sub `type`. The machine's
+     * `subscribe` table holds the seam's runner under it, so it must be unique
+     * among the machine's Sub types.
      */
-    readonly name: string;
+    readonly name: N;
     /**
      * Build the transport. The battery owns the lifetime; the factory is the
      * platform-specific constructor (`new WebSocket(...)` adapter on a DO,
@@ -753,53 +553,42 @@ interface FromTransportOpts<TKey, Inbound, Outbound, M, Ctx> {
     readonly serializeOutbound: (outbound: Outbound) => string;
 }
 /**
- * What the battery returns: a Sub builder (for `subscriptions`), the Sub's
- * `subscribe` handler (for `subscribe.transport`), and a `send(key, outbound)`
- * helper the consumer's Cmd handler calls. Plus a `subIdFor` factory the
- * consumer can use when keying related Subs (e.g. a deadline) to the same seam
- * identity.
+ * What the battery returns: a `.depKeyed(when)` entry for the machine's
+ * `subs`, the `.subscribe` runner for the `subscribe` table handed to `run`,
+ * and a `send(key, outbound)` helper the consumer's Cmd handler calls.
  */
-interface TransportBattery<TKey, Outbound, M, Ctx> {
+interface TransportBattery<N extends string, TKey, Outbound, M, Ctx> {
+    /** The seam's Sub type — its `name`. */
+    readonly type: N;
     /**
-     * Build the Sub for `subscriptions(state)`. The consumer calls this from
-     * inside their `subscriptions` cell when the seam should be open.
+     * The `subs` entry. `when(state)` returns the seam's KEY when it should be
+     * open, or `null` when it should be torn down. The key is the Sub's `deps`,
+     * so the engine derives the id from it: an unchanged key leaves the seam
+     * open, a changed key closes it and opens a fresh one. Plain
+     * JSON-compatible data only — the id hash throws on anything else.
      */
-    readonly sub: (key: TKey) => TransportSub<TKey>;
+    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, TransportSub<N, TKey>>;
     /**
-     * The `subscribe.transport` handler. Drop straight into the machine's
-     * `subscribe` record — the battery wires inbound + close in one shot.
+     * The runner for this seam's Sub type — hand it to `run` as
+     * `subscribe: { [seam.type]: seam.subscribe }`. Wires inbound + close in
+     * one shot and publishes the live transport to the outbound handle table.
      */
-    readonly subscribe: (sub: TransportSub<TKey>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
+    readonly subscribe: (sub: TransportSub<N, TKey>, ctx: Ctx, dispatch: (msg: M) => void) => Dispose;
     /**
-     * Outbound send. The Cmd handler calls this; the battery's handle table
-     * (built when subscribe ran) routes to the live transport. If the seam
-     * is closed (no active sub), the send is dropped honestly (logged, not
-     * thrown — the reducer already moved past caring, same shape as Rule 2
-     * fire-and-forget Cmds).
+     * Outbound send, addressed by the seam's key (never the derived Sub id,
+     * which the caller cannot know). The Cmd handler calls this; the battery's
+     * handle table (built when the runner started) routes to the live
+     * transport. If the seam is closed (no running Sub), the send is dropped
+     * honestly (logged, not thrown — the reducer already moved past caring,
+     * same shape as Rule 2 fire-and-forget Cmds).
      */
     readonly send: (key: TKey, outbound: Outbound) => void;
-    /** Pre-derived subId for `(key)` — handy for deadline Subs keyed to the same seam. */
-    readonly subIdFor: (key: TKey) => SubId;
-    /**
-     * Pair this seam with a state-gate, producing a dep-keyed Sub for the
-     * machine's `subs` array. `when(state)` returns the seam's KEY when it
-     * should be open, or `null` when it should be torn down. The kernel derives
-     * the id from `structuralHash(key)` and reconciles the seam's lifetime — so
-     * the author neither lists this Sub in a central `subscriptions(state)` nor
-     * writes its id. Replaces `subscriptions: (s) => active(s) ? [hands.sub(...)] : []`
-     * + `subscribe: { transport: hands.subscribe }` with one `subs` entry.
-     *
-     * The `source` closes over the battery's own `subscribe` (open inbound +
-     * close, wire the handle table) using the same `ctx` the kernel passes every
-     * Sub source.
-     */
-    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, M, Ctx>;
 }
 /**
  * Build the battery. One call per seam at the machine's host file.
  *
  * @example
- *   const handsSeam = fromTransport<RunId, HandsInbound, HandsOutbound, Msg, Ctx>({
+ *   const handsSeam = fromTransport<"hands", RunId, HandsInbound, HandsOutbound, Msg, Ctx>({
  *     name: "hands",
  *     openTransport: (runId, ctx) => ctx.openHandsWs(runId),
  *     parseInbound: (raw) => parseHandsInbound(JSON.parse(raw)),
@@ -809,12 +598,19 @@ interface TransportBattery<TKey, Outbound, M, Ctx> {
  *   });
  *
  *   // In the machine:
- *   subscriptions: (state) => state.type === "auditing" ? [handsSeam.sub(state.runId)] : [],
- *   subscribe: { transport: handsSeam.subscribe },
+ *   types: { …, sub: {} as TransportSub<"hands", RunId> },
+ *   subs: [
+ *     handsSeam.depKeyed((s: State) =>
+ *       s.type === "auditing" ? s.runId : null,
+ *     ),
+ *   ],
+ *
+ *   // At run:
+ *   run(machine, { interpret, subscribe: { hands: handsSeam.subscribe } });
  *
  *   // In interpret:
  *   send_hands: async (cmd) => { handsSeam.send(cmd.runId, cmd.outbound); },
  */
-declare function fromTransport<TKey, Inbound, Outbound, M, Ctx>(opts: FromTransportOpts<TKey, Inbound, Outbound, M, Ctx>): TransportBattery<TKey, Outbound, M, Ctx>;
+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>;
 
-export { type Ack, type AckPartition, BootingRuntime, type CancelTimer, Cmd, type CombinedManagedResources, type DefineManagedResourceOpts, DepKeyedSub, Dispose, type DriveToDoneOptions, type EventSourceFactoryOpts, type FromTransportOpts, type GatedManagedResource, type HistoryTracker, type ListenerTarget, Machine, type ManagedResourceBattery, type ManagedResourceSub, NO_ACK, OnError, Port, type ReconnectingWebSocketFactoryOpts, RequiredCtx, Runtime, ScopedCtxArg, type Seq, type SeqTagged, Store, Sub, SubId, SubscribeHandler, Supervision, type Transport, type TransportBattery, type TransportFactory, type TransportSub, type WebSocketFactoryOpts, type WebSocketSubData, ack, combineManagedResources, defineListener, defineManagedResource, driveToDone, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, nextSeq, partitionByAck, reconcile, run, tagSeq };
+export { type Ack, type AckPartition, BootingRuntime, type CancelTimer, Cmd, type DefineManagedResourceOpts, DepKeyedSub, Dispose, type EventSourceFactoryOpts, type FromTransportOpts, type HistoryTracker, type ListenerTarget, Machine, type ManagedResourceBattery, type ManagedResourceSub, NO_ACK, Port, type ReadStep, type ReconnectingWebSocketFactoryOpts, Runtime, type Seq, type SeqTagged, Sub, SubscribeHandler, type Transport, type TransportBattery, type TransportFactory, type TransportSub, type WebSocketFactoryOpts, type WebSocketSubData, ack, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket, historyTracker, initAck, liftSlice, nextSeq, partitionByAck, readInOrder, reconcile, tagSeq };