@demlik/tea 0.14.0 → 0.16.0

package/dist/do/index.d.ts

@@ -1,18 +1,18 @@
-import { S as Store, R as Runtime, B as BootingRuntime, F as FencedStore } from '../runtime-types-LWDoi943.js';
-import { P as PendingEffectsRecorder, b as EffectOwed, a as EffectConfirmed } from '../durable-effects-B0-qGQDy.js';
-export { D as DeliveryId, E as EffectLedgerEvent, O as OwedEffect, c as PendingEffectsLedger, d as applyEffectEvent, e as emptyLedger, f as foldLedger, i as isOwed, p as pendingEffectsLedger, s as survivingEffects } from '../durable-effects-B0-qGQDy.js';
+import { S as Store, b as BootedRunHandle, E as EngineRun, c as RunHandle, F as FencedStore } from '../runtime-types-CiVpC0HN.js';
+import { P as PendingEffectsRecorder, b as EffectOwed, a as EffectConfirmed } from '../durable-effects-7MTK_jnj.js';
+export { D as DeliveryId, E as EffectLedgerEvent, O as OwedEffect, c as PendingEffectsLedger, d as applyEffectEvent, e as emptyLedger, f as foldLedger, i as isOwed, p as pendingEffectsLedger, s as survivingEffects } from '../durable-effects-7MTK_jnj.js';
 import { RetryPolicy, Rng } from '../retry-backoff/index.js';
-import { C as Cmd, S as Sub, M as Machine, R as RequiredCtx } from '../core-CTzMJ82M.js';
-import { g as AgentEvent, b as AgentTurn, c as AgentState, i as AgentMachineMsg, D as AgentStatus } from '../machine-CdIcN2Xm.js';
-import 'better-result';
-import 'zod';
-import '../index-NjrT3fL2.js';
-import '../index-DMCeMPMJ.js';
-import '../index-q0hXFeZ0.js';
-import '../types-DP3f5NIl.js';
-import '../index-DJWIER_3.js';
-import '../index-B5BZ-_cT.js';
-import '../index-6A7dB8f6.js';
+import { C as Cmd, S as Sub, M as Machine, W as Wired } from '../core-BbgtiXdg.js';
+import { g as AgentEvent, b as AgentTurn, c as AgentState, i as AgentMachineMsg, B as AgentStatus } from '../machine-BQzTV8On.js';
+import '@standard-schema/spec';
+import '../index-Bz5Rh9Ga.js';
+import '../index-CjFDUBeq.js';
+import '../index-Xufl55W8.js';
+import '../types-LxZxGYda.js';
+import '../index-7vV8xmsD.js';
+import '../index-Cou86-GX.js';
+import '../protocol-ClRZBhHQ.js';
+import '../index-CkFYA9Y6.js';
 
 /**
  * @demlik/tea/do — `stepHost`, the HTTP-PULL control carrier (#92).
@@ -407,7 +407,7 @@ declare function runStepLoop<R, I, O>(token: string, runId: string, transport: S
  * and the vortex arena tick (`room.ts` `armTick` + `onTick`) replicates the
  * exact shape for the 18 Hz game clock. The two old `do_alarm`/`do_ws` Subs were
  * dropped (see `./index`'s historical note) because `toMachine` fixes the agent
- * machine's Sub type to `DeadlineSub`, so they could never union into a grain's
+ * machine's Sub type to `DeadlinesSub`, so they could never union into a grain's
  * Sub set — leaving the alarm re-arm a HOST concern with no first-class home.
  *
  * {@link durableTimer} is that home: a tiny, transport- and Msg-agnostic helper
@@ -1056,18 +1056,22 @@ declare function sseFromAgentEvents<R, Frame>(runtime: {
  */
 interface AgentHostConfig<Stage, P extends string, O extends Record<P, AgentTurn>, R, Frame, C extends Cmd = Cmd, U extends Sub = Sub, Ctx = unknown> {
     /**
-     * Build the wired agent machine. Called once per host build (per activation),
-     * AFTER the previous runtime — if any — was torn down. The consumer wires its
-     * per-tool interpret here (`agent.toMachine({ toolInterpret })`).
+     * The engine's `run` — `run` from `@demlik/tea/promise`, or any engine's. The
+     * host imports no engine; it boots the machine through this.
      */
-    readonly buildMachine: () => Machine<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, C, U, Ctx>;
-    /** The durable `Store` for the agent slice (typically `doStore(storage, parse)`). */
-    readonly store: Store<AgentState<Stage, P, O, R>>;
+    readonly run: EngineRun<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, C, U, Ctx, AgentEvent<R>>;
     /**
-     * The Ctx the machine threads to its interpret cells — checked against
-     * `buildMachine`'s, plus every typed Cmd's `R` (what `run` itself demands).
+     * Build the wired agent machine and the handlers it runs under — its
+     * `interpret` table and `subscribe` runners (a machine carries none — #278,
+     * #279). Called once per host build (per activation), AFTER the previous
+     * runtime — if any — was torn down. The consumer wires its per-tool interpret
+     * here, and `agent.toMachine({ toolInterpret })` already returns exactly this.
      */
-    readonly ctx: Ctx & RequiredCtx<C>;
+    readonly buildMachine: () => Wired<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, C, U, Ctx>;
+    /** The durable `Store` for the agent slice (typically `doStore(storage, parse)`). */
+    readonly store: Store<AgentState<Stage, P, O, R>>;
+    /** The plain Ctx the machine threads to its interpret cells. */
+    readonly ctx: Ctx;
     /**
      * The run-terminality predicate (#46) — what makes `result()` first-class.
      * Defaults to the agent's own terminal phases (`done` / `failed`).
@@ -1098,10 +1102,10 @@ interface AgentHost<Stage, P extends string, O extends Record<P, AgentTurn>, R,
      * Get (or build) the booted runtime. Build-once-boot-once: the first call
      * builds the machine, wires SSE off the semantic event stream, awaits the boot
      * gate, runs the `autoBoot` re-fire for a rehydrated suspended run, and caches
-     * the booted `Runtime`; subsequent calls return the cached handle. The single
+     * the booted handle; subsequent calls return the cached handle. The single
      * assembly every consumer used to hand-roll in `getRuntime()`.
      */
-    runtime(): Promise<Runtime<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, AgentEvent<R>>>;
+    runtime(): Promise<BootedRunHandle<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, AgentEvent<R>>>;
     /**
      * The agent's lifecycle status (#49) — the ONE typed channel a consumer reads
      * instead of re-deriving `run.phase` / `awaiting` by hand. Ensures the runtime
@@ -1137,6 +1141,7 @@ interface AgentHost<Stage, P extends string, O extends Record<P, AgentTurn>, R,
  *
  * @example
  *   const host = createAgentHost<Stage, Purpose, Outputs, ClientResult, SseEvent>({
+ *     run, // from `@demlik/tea/promise`
  *     buildMachine: () => agent.toMachine<Ctx>({ toolInterpret }),
  *     store: doStore(storage, parse),
  *     ctx,
@@ -1372,14 +1377,14 @@ interface ResumePort<S, M extends {
  * every DO-hosted machine otherwise re-derives.
  *
  * `await ready` is the single boot gate (issue #45): `getState()` is total only
- * on the booted `Runtime`, so state cannot be inspected before boot populates
- * it. `now` is injected (the sole boot clock read) so a test can pin it.
+ * on the booted handle, so state cannot be inspected before boot populates
+ * it. Takes any engine's {@link RunHandle}. `now` is injected (the sole boot clock read) so a test can pin it.
  */
 declare function bootResume<S, M extends {
     type: string;
 }, E extends {
     type: string;
-} = never>(booting: BootingRuntime<S, M, E>, port: ResumePort<S, M>, now?: () => number): Promise<void>;
+} = never>(booting: RunHandle<S, M, E>, port: ResumePort<S, M>, now?: () => number): Promise<void>;
 /**
  * True iff an agent slice loaded from storage is mid-loop (running + awaiting
  * tools) — the resumable case `agent_boot` re-fires.
@@ -1403,7 +1408,7 @@ declare function agentIsResumable<Stage, P extends string, O extends Record<P, u
  */
 declare function autoBoot<Stage, P extends string, O extends Record<P, unknown>, R, E extends {
     type: string;
-} = never>(booting: BootingRuntime<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, E>, now?: () => number): Promise<void>;
+} = never>(booting: RunHandle<AgentState<Stage, P, O, R>, AgentMachineMsg<P, O, R>, E>, now?: () => number): Promise<void>;
 /**
  * Re-fire every round-trip a rehydrated actor still owes, on wake. Given a
  * durable carrier whose recorder was rehydrated from the persisted ledger
@@ -1833,7 +1838,7 @@ declare function presenceCount(ctx: PresenceCtx, tag?: string): number;
  *
  *   2. `deferredGateway` + `createAgentHost` (from `./host`) — THE transport for
  *      a DO-hosted agent. A `createAgent().toMachine()` machine owns exactly one
- *      Sub type, `DeadlineSub` (the agent's own retry + watchdog timers); it has
+ *      Sub type, `DeadlinesSub` (the agent's own retry + watchdog timers); it has
  *      no DO-native Sub variant to compose, and it needs none. The gateway owns
  *      each deferred tool round-trip as a Promise the interpret cell awaits:
  *        - Inbound WebSocket frames are bridged straight into `gateway.settle(...)`
@@ -1847,7 +1852,7 @@ declare function presenceCount(ctx: PresenceCtx, tag?: string): number;
  *
  * (Historical note: this module previously also shipped `do_ws` / `do_alarm`
  * Subs + a `doSubscribe` registry. Because `toMachine` fixes the agent machine's
- * Sub type to `DeadlineSub`, those Subs could never union into an agent host's
+ * Sub type to `DeadlinesSub`, those Subs could never union into an agent host's
  * Sub set — they were structurally unusable by the flagship consumer and had no
  * callers. They were dropped in favor of the gateway as the single transport.)
  */

package/dist/do/index.js

@@ -1,16 +1,20 @@
-import { status, agentBootMsg, agentEvents } from '../chunk-Z2L3LSNV.js';
-import { createIntake } from '../chunk-LYLTKJWM.js';
+import { status, agentBootMsg, agentEvents } from '../chunk-EHUDXAKC.js';
+import '../chunk-G5E74IJB.js';
+import { createIntake } from '../chunk-MYNLY3HP.js';
 export { applyEffectEvent, emptyLedger, foldLedger, isOwed, pendingEffectsLedger, survivingEffects } from '../chunk-6IQPODUF.js';
-import '../chunk-HYDWG35Q.js';
-import '../chunk-MYXFNWAJ.js';
+import '../chunk-7MGXQZPW.js';
+import '../chunk-CIHSHLQX.js';
+import '../chunk-QNGYQMZB.js';
 import '../chunk-PR6TB3BL.js';
 import '../chunk-TXN2KFHF.js';
-import '../chunk-HUKZQX6U.js';
-import '../chunk-AQ6ZIMEA.js';
+import '../chunk-6NG4V5SB.js';
 import { defaultRetryPolicy, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-VBDU4JL6.js';
-import '../chunk-F2US5BW6.js';
-import '../chunk-G5E74IJB.js';
-import { StoreConflictError, replay, run } from '../chunk-RQULHGYH.js';
+import '../chunk-4LPY67E4.js';
+import '../chunk-IVJP3GKJ.js';
+import '../chunk-WT5PBPLB.js';
+import '../chunk-5XU6ZJO2.js';
+import '../chunk-GOX2CYIM.js';
+import { StoreConflictError, replay } from '../chunk-CH5KTOEZ.js';
 
 // src/do/durable-timer.ts
 function durableTimer(config) {
@@ -247,11 +251,13 @@ function createAgentHost(config) {
   const isTerminal = config.terminal ?? ((s) => s.run.phase === "done" || s.run.phase === "failed" || s.run.phase === "cancelled");
   let cached = null;
   async function build() {
-    const booting = run(config.buildMachine(), {
-      ctx: config.ctx,
+    const wired = config.buildMachine();
+    const ctxArg = { ctx: config.ctx };
+    const booting = config.run(wired.machine, {
+      ...wired,
+      ...ctxArg,
       store: config.store,
-      events: agentEvents(),
-      terminal: isTerminal
+      events: agentEvents()
     });
     sseFromAgentEvents(booting, sse, config.toSseFrame);
     await autoBoot(booting, now);
@@ -272,7 +278,8 @@ function createAgentHost(config) {
       return status((await runtime()).getState());
     },
     async result() {
-      return (await runtime()).result();
+      const state = (await runtime()).getState();
+      return isTerminal(state) ? state : void 0;
     },
     sse,
     async reset() {