@demlik/tea 0.1.2 → 0.3.0

package/dist/do/index.js

@@ -1,25 +1,27 @@
-import { status, agentBootMsg, agentEvents } from '../chunk-S3FQN4SL.js';
-import '../chunk-7W4LMPUW.js';
-import '../chunk-PS23H6KQ.js';
-export { applyEffectEvent, emptyLedger, foldLedger, isOwed, pendingEffectsLedger, survivingEffects } from '../chunk-3545BOYL.js';
-import '../chunk-EHIX7NYZ.js';
-import '../chunk-27N2SPTN.js';
+import { status, agentBootMsg, agentEvents } from '../chunk-WGGAMW7Y.js';
+export { applyEffectEvent, emptyLedger, foldLedger, isOwed, pendingEffectsLedger, survivingEffects } from '../chunk-25LBDCBC.js';
+import '../chunk-CAXMQJJ3.js';
+import '../chunk-VBUCHVCV.js';
+import '../chunk-MVY5DAMF.js';
+import '../chunk-IXBKFQH5.js';
 import '../chunk-JELSZN25.js';
-import '../chunk-UV6UWGEO.js';
-import { createIntake } from '../chunk-LEC4U6CX.js';
-import '../chunk-K7Q23EQ4.js';
-import { defaultRetryPolicy, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-5VNWZADP.js';
-import '../chunk-2YOE5PIS.js';
+import '../chunk-D736QUGF.js';
+import { createIntake } from '../chunk-ZVJZ72HY.js';
+import '../chunk-RMX4EOQK.js';
+import { defaultRetryPolicy, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-Q2UM7BXU.js';
+import '../chunk-S2EGRPCM.js';
 import '../chunk-BYQUGDD3.js';
 import '../chunk-K575PT4S.js';
-import '../chunk-SC3FAFZN.js';
-import '../chunk-IN33Q4VJ.js';
-import '../chunk-HJO6VNQI.js';
-import '../chunk-TGG26XMK.js';
-import '../chunk-NSDFA6M6.js';
+import '../chunk-UF4MZSLT.js';
+import '../chunk-2KNLKQVN.js';
+import '../chunk-MU6MCIAC.js';
+import '../chunk-FV3Z5MBE.js';
+import '../chunk-LYLDCIPH.js';
 import '../chunk-2YFLOCWX.js';
-import { run, replay } from '../chunk-MMH7CW5K.js';
-import '../chunk-QLA76GIT.js';
+import '../chunk-ZJ5AOYBH.js';
+import '../chunk-G5E74IJB.js';
+import { replay, run } from '../chunk-BP2R7TPP.js';
+import '../chunk-PBDYW2TU.js';
 
 // src/do/durable-timer.ts
 function durableTimer(config) {
@@ -69,6 +71,10 @@ function doEventSourcedStore(storage, machine, ctx, opts = {}) {
     const meta = JSON.parse(raw);
     return typeof meta.lastSeq === "number" ? meta.lastSeq : 0;
   }
+  async function ensureLastSeq() {
+    if (lastSeq === null) lastSeq = await readMeta();
+    return lastSeq;
+  }
   async function readSnapshot() {
     const raw = await storage.get(snapshotKey);
     if (raw === void 0 || raw === null) return { state: null, seq: 0 };
@@ -126,8 +132,7 @@ function doEventSourcedStore(storage, machine, ctx, opts = {}) {
     snapshotSeq = seq;
   }
   async function append(msg) {
-    if (lastSeq === null) lastSeq = await readMeta();
-    const seq = lastSeq + 1;
+    const seq = await ensureLastSeq() + 1;
     lastSeq = seq;
     await storage.put(eventKey(eventPrefix, seq), JSON.stringify(msg));
     await storage.put(
@@ -139,95 +144,15 @@ function doEventSourcedStore(storage, machine, ctx, opts = {}) {
     }
   }
   async function snapshotNow() {
-    if (lastSeq === null) lastSeq = await readMeta();
-    if (latestState === null || lastSeq <= snapshotSeq) return false;
-    await writeSnapshot(lastSeq, latestState);
+    const seq = await ensureLastSeq();
+    if (latestState === null || seq <= snapshotSeq) return false;
+    await writeSnapshot(seq, latestState);
     return true;
   }
   return { store, append, snapshotNow, readEvents };
 }
 
-// src/do/host.ts
-function deferredGateway() {
-  const pending = /* @__PURE__ */ new Map();
-  return {
-    await(callId, send, deadlineMs) {
-      const existing = pending.get(callId);
-      if (existing !== void 0) return existing.promise;
-      let resolve;
-      let reject;
-      const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      });
-      const timer = setTimeout(() => {
-        if (pending.delete(callId)) {
-          reject(new Error(`deadline_exceeded after ${deadlineMs}ms`));
-        }
-      }, deadlineMs);
-      pending.set(callId, {
-        resolve: (v) => {
-          clearTimeout(timer);
-          resolve(v);
-        },
-        reject: (e) => {
-          clearTimeout(timer);
-          reject(e);
-        },
-        promise
-      });
-      send();
-      return promise;
-    },
-    settle(callId, result) {
-      const entry = pending.get(callId);
-      if (entry === void 0) return;
-      pending.delete(callId);
-      entry.resolve(result);
-    },
-    fail(callId, reason) {
-      const entry = pending.get(callId);
-      if (entry === void 0) return;
-      pending.delete(callId);
-      entry.reject(new Error(reason));
-    },
-    inFlight() {
-      return [...pending.keys()];
-    }
-  };
-}
-function durableDeferredGateway(inner, recorder, hooks) {
-  const idByCallId = /* @__PURE__ */ new Map();
-  return {
-    recorder,
-    await(callId, send, deadlineMs) {
-      if (!idByCallId.has(callId)) {
-        const { id, event } = recorder.owe({ callId });
-        idByCallId.set(callId, id);
-        hooks.recordOwed(callId, event);
-      }
-      return inner.await(callId, send, deadlineMs);
-    },
-    settle(callId, result) {
-      confirm(callId);
-      inner.settle(callId, result);
-    },
-    fail(callId, reason) {
-      confirm(callId);
-      inner.fail(callId, reason);
-    },
-    inFlight() {
-      return inner.inFlight();
-    }
-  };
-  function confirm(callId) {
-    const id = idByCallId.get(callId);
-    if (id === void 0) return;
-    idByCallId.delete(callId);
-    const { event } = recorder.confirm(id);
-    hooks.recordConfirmed(callId, event);
-  }
-}
+// src/do/resume.ts
 async function bootResume(booting, port, now = Date.now) {
   const runtime = await booting.ready;
   if (port.isResumable(runtime.getState())) {
@@ -244,44 +169,6 @@ async function autoBoot(booting, now = Date.now) {
     now
   );
 }
-function acceptCommandSocket(clients, onFrame) {
-  const pair = new WebSocketPair();
-  const [client, server] = [pair[0], pair[1]];
-  server.accept();
-  clients.add(server);
-  server.addEventListener("message", (ev) => {
-    if (typeof ev.data === "string") onFrame(ev.data);
-  });
-  server.addEventListener("close", () => clients.delete(server));
-  return new Response(null, { status: 101, webSocket: client });
-}
-function broadcast(clients, frame) {
-  const json = JSON.stringify(frame);
-  for (const ws of clients) {
-    try {
-      ws.send(json);
-    } catch {
-    }
-  }
-}
-function acceptDurableCommandSocket(ctx) {
-  const pair = new WebSocketPair();
-  const [client, server] = [pair[0], pair[1]];
-  ctx.acceptWebSocket(server);
-  return new Response(null, { status: 101, webSocket: client });
-}
-function broadcastHibernatable(ctx, frame) {
-  const json = JSON.stringify(frame);
-  for (const ws of ctx.getWebSockets()) {
-    try {
-      ws.send(json);
-    } catch {
-    }
-  }
-}
-function durableCommandCarrier(inner, recorder, hooks) {
-  return durableDeferredGateway(inner, recorder, hooks);
-}
 function reissueSurvivingEffects(carrier, reissue) {
   const reemitted = [];
   for (const { effect } of carrier.recorder.surviving()) {
@@ -290,6 +177,8 @@ function reissueSurvivingEffects(carrier, reissue) {
   }
   return reemitted;
 }
+
+// src/do/sse.ts
 function sseHub() {
   const sinks = /* @__PURE__ */ new Set();
   const encoder = new TextEncoder();
@@ -361,13 +250,14 @@ function sseFromAgentEvents(runtime, hub, toFrame) {
     for (const off of offs) off();
   };
 }
+
+// src/do/agent-host.ts
 function createAgentHost(config) {
   const sse = sseHub();
   const now = config.now ?? Date.now;
   const isTerminal = config.terminal ?? ((s) => s.run.phase === "done" || s.run.phase === "failed");
   let cached = null;
-  async function runtime() {
-    if (cached !== null) return cached;
+  async function build() {
     const booting = run(config.buildMachine(), {
       ctx: config.ctx,
       store: config.store,
@@ -376,7 +266,15 @@ function createAgentHost(config) {
     });
     sseFromAgentEvents(booting, sse, config.toSseFrame);
     await autoBoot(booting, now);
-    cached = await booting.ready;
+    return booting.ready;
+  }
+  function runtime() {
+    if (cached !== null) return cached;
+    const building = build();
+    cached = building;
+    building.catch(() => {
+      if (cached === building) cached = null;
+    });
     return cached;
   }
   return {
@@ -390,11 +288,171 @@ function createAgentHost(config) {
     sse,
     async reset() {
       if (cached === null) return;
-      await cached.stop();
+      const built = await cached.catch(() => null);
       cached = null;
+      await built?.stop();
+    }
+  };
+}
+
+// src/do/presence.ts
+var WS_READY_STATE_OPEN = 1;
+function broadcastFrame(sockets, frame, options) {
+  const serialize = options?.serialize ?? JSON.stringify;
+  const except = options?.except;
+  const json = serialize(frame);
+  let sent = 0;
+  let skipped = 0;
+  for (const ws of sockets) {
+    if (except !== void 0 && ws === except) {
+      skipped++;
+      continue;
+    }
+    if (ws.readyState !== void 0 && ws.readyState !== WS_READY_STATE_OPEN) {
+      skipped++;
+      continue;
+    }
+    try {
+      ws.send(json);
+      sent++;
+    } catch {
+      skipped++;
+    }
+  }
+  return { sent, skipped };
+}
+function registerHibernatableSocket(ctx, server, options) {
+  ctx.acceptWebSocket(
+    server,
+    options?.tags === void 0 ? void 0 : [...options.tags]
+  );
+  if (options?.attachment !== void 0) {
+    server.serializeAttachment(options.attachment);
+  }
+}
+function acceptPresenceSocket(ctx, options) {
+  const pair = new WebSocketPair();
+  const client = pair[0];
+  const server = pair[1];
+  registerHibernatableSocket(ctx, server, options);
+  return {
+    server,
+    response: new Response(null, { status: 101, webSocket: client })
+  };
+}
+function presenceCount(ctx, tag) {
+  return ctx.getWebSockets(tag).length;
+}
+
+// src/do/command-socket.ts
+function acceptCommandSocket(clients, onFrame) {
+  const pair = new WebSocketPair();
+  const [client, server] = [pair[0], pair[1]];
+  server.accept();
+  clients.add(server);
+  server.addEventListener("message", (ev) => {
+    if (typeof ev.data === "string") onFrame(ev.data);
+  });
+  server.addEventListener("close", () => clients.delete(server));
+  return new Response(null, { status: 101, webSocket: client });
+}
+function broadcast(clients, frame) {
+  broadcastFrame(clients, frame);
+}
+function acceptDurableCommandSocket(ctx) {
+  const pair = new WebSocketPair();
+  const [client, server] = [pair[0], pair[1]];
+  ctx.acceptWebSocket(server);
+  return new Response(null, { status: 101, webSocket: client });
+}
+function broadcastHibernatable(ctx, frame) {
+  broadcastFrame(ctx.getWebSockets(), frame);
+}
+
+// src/do/deferred-gateway.ts
+function deferredGateway() {
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    await(callId, send, deadlineMs) {
+      const existing = pending.get(callId);
+      if (existing !== void 0) return existing.promise;
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      const timer = setTimeout(() => {
+        if (pending.delete(callId)) {
+          reject(new Error(`deadline_exceeded after ${deadlineMs}ms`));
+        }
+      }, deadlineMs);
+      pending.set(callId, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        },
+        promise
+      });
+      send();
+      return promise;
+    },
+    settle(callId, result) {
+      const entry = pending.get(callId);
+      if (entry === void 0) return;
+      pending.delete(callId);
+      entry.resolve(result);
+    },
+    fail(callId, reason) {
+      const entry = pending.get(callId);
+      if (entry === void 0) return;
+      pending.delete(callId);
+      entry.reject(new Error(reason));
+    },
+    inFlight() {
+      return [...pending.keys()];
     }
   };
 }
+function durableDeferredGateway(inner, recorder, hooks) {
+  const idByCallId = /* @__PURE__ */ new Map();
+  return {
+    recorder,
+    await(callId, send, deadlineMs) {
+      if (!idByCallId.has(callId)) {
+        const { id, event } = recorder.owe({ callId });
+        idByCallId.set(callId, id);
+        hooks.recordOwed(callId, event);
+      }
+      return inner.await(callId, send, deadlineMs);
+    },
+    settle(callId, result) {
+      confirm(callId);
+      inner.settle(callId, result);
+    },
+    fail(callId, reason) {
+      confirm(callId);
+      inner.fail(callId, reason);
+    },
+    inFlight() {
+      return inner.inFlight();
+    }
+  };
+  function confirm(callId) {
+    const id = idByCallId.get(callId);
+    if (id === void 0) return;
+    idByCallId.delete(callId);
+    const { event } = recorder.confirm(id);
+    hooks.recordConfirmed(callId, event);
+  }
+}
+function durableCommandCarrier(inner, recorder, hooks) {
+  return durableDeferredGateway(inner, recorder, hooks);
+}
 
 // src/do/idempotent-effect.ts
 function emptyApplied() {
@@ -453,55 +511,6 @@ function appliedEffects(restore) {
   };
 }
 
-// src/do/presence.ts
-var WS_READY_STATE_OPEN = 1;
-function broadcastFrame(sockets, frame, options) {
-  const serialize = options?.serialize ?? JSON.stringify;
-  const except = options?.except;
-  const json = serialize(frame);
-  let sent = 0;
-  let skipped = 0;
-  for (const ws of sockets) {
-    if (except !== void 0 && ws === except) {
-      skipped++;
-      continue;
-    }
-    if (ws.readyState !== void 0 && ws.readyState !== WS_READY_STATE_OPEN) {
-      skipped++;
-      continue;
-    }
-    try {
-      ws.send(json);
-      sent++;
-    } catch {
-      skipped++;
-    }
-  }
-  return { sent, skipped };
-}
-function registerHibernatableSocket(ctx, server, options) {
-  ctx.acceptWebSocket(
-    server,
-    options?.tags === void 0 ? void 0 : [...options.tags]
-  );
-  if (options?.attachment !== void 0) {
-    server.serializeAttachment(options.attachment);
-  }
-}
-function acceptPresenceSocket(ctx, options) {
-  const pair = new WebSocketPair();
-  const client = pair[0];
-  const server = pair[1];
-  registerHibernatableSocket(ctx, server, options);
-  return {
-    server,
-    response: new Response(null, { status: 101, webSocket: client })
-  };
-}
-function presenceCount(ctx, tag) {
-  return ctx.getWebSockets(tag).length;
-}
-
 // src/do/projection.ts
 function projectionIdString(id) {
   return `${id.name}-${id.key}`;
@@ -527,7 +536,7 @@ function runProjection(projection, startOffset = 0) {
     }
   };
 }
-function projectionRegistry() {
+function projectionRegistry(onError) {
   const runners = /* @__PURE__ */ new Set();
   let counter = -1;
   return {
@@ -542,7 +551,8 @@ function projectionRegistry() {
       for (const runner of runners) {
         try {
           runner.present(update);
-        } catch {
+        } catch (err) {
+          onError?.(err, { id: runner.id });
         }
       }
       return offset;
@@ -593,8 +603,12 @@ function constantTimeEqual(a, b) {
   return diff === 0 && lengthMatches;
 }
 var DEFAULT_GIVE_UP_MS = 5 * 6e4;
+function workingBody(retryAfterMs) {
+  return retryAfterMs === void 0 ? { done: false, working: true } : { done: false, working: true, retryAfterMs };
+}
 function stepHost(ctx, engine, config = {}) {
   const giveUpAfterMs = config.giveUpAfterMs ?? DEFAULT_GIVE_UP_MS;
+  const deferResume = "deferResume" in config ? config.deferResume : null;
   const intake = createIntake({
     keyOf: (posted) => posted.callId
   });
@@ -610,23 +624,31 @@ function stepHost(ctx, engine, config = {}) {
     await ctx.storage.setAlarm(now + giveUpAfterMs);
     const posted = request.posted;
     if (posted !== null) {
-      const [nextIntake, cmds] = intake.receive(
-        intakeState,
-        posted,
-        now,
-        posted.callId
-      );
-      intakeState = nextIntake;
-      for (const cmd of cmds) {
-        if (cmd.type === "intake:process") {
-          await engine.resume(request.runId, posted);
-          const [completed] = intake.complete(
-            intakeState,
-            cmd.key,
-            "settled",
-            now
-          );
-          intakeState = completed;
+      if (deferResume === null) {
+        const [nextIntake, cmds] = intake.receive(
+          intakeState,
+          posted,
+          now,
+          posted.callId
+        );
+        intakeState = nextIntake;
+        for (const cmd of cmds) {
+          if (cmd.type === "intake:process") {
+            await engine.resume(request.runId, posted);
+            const [completed] = intake.complete(
+              intakeState,
+              cmd.key,
+              "settled",
+              now
+            );
+            intakeState = completed;
+          }
+        }
+      } else {
+        const ready = await deferResume.settled(request.runId, posted.callId);
+        if (!ready) {
+          await deferResume.enqueue(request.runId, posted);
+          return { status: 200, body: workingBody(deferResume.retryAfterMs) };
         }
       }
     }
@@ -646,6 +668,7 @@ async function runStepLoop(token, runId, transport, execute, config) {
   const rng = config.rng;
   const executed = /* @__PURE__ */ new Map();
   let posted = null;
+  let pollRetry = initRetry();
   for (; ; ) {
     if (now() >= config.deadlineMs) return { kind: "deadline_exceeded" };
     let response;
@@ -662,6 +685,13 @@ async function runStepLoop(token, runId, transport, execute, config) {
       }
     }
     if (response.done) return { kind: "done", output: response.output };
+    if ("working" in response) {
+      pollRetry = recordFailure(pollRetry, "working");
+      if (now() >= config.deadlineMs) return { kind: "deadline_exceeded" };
+      await sleep(response.retryAfterMs ?? nextDelayMs(pollRetry, policy, rng));
+      continue;
+    }
+    pollRetry = initRetry();
     const step = response.step;
     const cached = executed.get(step.callId);
     const result = cached !== void 0 ? cached : await execute(step);