@demlik/tea 0.1.2 → 0.2.0

package/dist/do/index.js

@@ -1,13 +1,13 @@
-import { status, agentBootMsg, agentEvents } from '../chunk-S3FQN4SL.js';
-import '../chunk-7W4LMPUW.js';
-import '../chunk-PS23H6KQ.js';
+import { status, agentBootMsg, agentEvents } from '../chunk-VFGKTGGC.js';
 export { applyEffectEvent, emptyLedger, foldLedger, isOwed, pendingEffectsLedger, survivingEffects } from '../chunk-3545BOYL.js';
-import '../chunk-EHIX7NYZ.js';
-import '../chunk-27N2SPTN.js';
+import '../chunk-ZDRN3YCE.js';
+import '../chunk-M6UZT7HS.js';
+import '../chunk-5KVHID6A.js';
+import '../chunk-6GIGQT6C.js';
 import '../chunk-JELSZN25.js';
 import '../chunk-UV6UWGEO.js';
 import { createIntake } from '../chunk-LEC4U6CX.js';
-import '../chunk-K7Q23EQ4.js';
+import '../chunk-SKAMZKTE.js';
 import { defaultRetryPolicy, initRetry, recordFailure, shouldRetry, nextDelayMs } from '../chunk-5VNWZADP.js';
 import '../chunk-2YOE5PIS.js';
 import '../chunk-BYQUGDD3.js';
@@ -18,8 +18,8 @@ import '../chunk-HJO6VNQI.js';
 import '../chunk-TGG26XMK.js';
 import '../chunk-NSDFA6M6.js';
 import '../chunk-2YFLOCWX.js';
-import { run, replay } from '../chunk-MMH7CW5K.js';
-import '../chunk-QLA76GIT.js';
+import { run, replay } from '../chunk-6VDCTR7N.js';
+import '../chunk-DYRKDCJI.js';
 
 // src/do/durable-timer.ts
 function durableTimer(config) {
@@ -147,87 +147,7 @@ function doEventSourcedStore(storage, machine, ctx, opts = {}) {
   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 +164,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 +172,8 @@ function reissueSurvivingEffects(carrier, reissue) {
   }
   return reemitted;
 }
+
+// src/do/sse.ts
 function sseHub() {
   const sinks = /* @__PURE__ */ new Set();
   const encoder = new TextEncoder();
@@ -361,6 +245,8 @@ 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;
@@ -396,6 +282,128 @@ function createAgentHost(config) {
   };
 }
 
+// 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) {
+  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 {
+    }
+  }
+}
+
+// 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() {
   return /* @__PURE__ */ new Set();
@@ -593,8 +601,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 +622,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 +666,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 +683,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);