@demlik/tea 0.1.0 → 0.1.2

package/dist/do/index.js

@@ -1,54 +1,696 @@
-// src/do/index.ts
-var DEFAULT_STATE_KEY = "@@state";
-function doStore(storage, parse, key = DEFAULT_STATE_KEY) {
-  return {
+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 '../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-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-2YFLOCWX.js';
+import { run, replay } from '../chunk-MMH7CW5K.js';
+import '../chunk-QLA76GIT.js';
+
+// src/do/durable-timer.ts
+function durableTimer(config) {
+  const { alarm, nextDeadline, onFire } = config;
+  const timer = {
+    async rearm() {
+      const at = await nextDeadline();
+      if (at !== null) await alarm.setAlarm(at);
+    },
+    async onAlarm() {
+      await onFire();
+      await timer.rearm();
+    }
+  };
+  return timer;
+}
+
+// src/do/event-sourced-store.ts
+var DEFAULT_SNAPSHOT_KEY = "@@es/snapshot";
+var DEFAULT_META_KEY = "@@es/meta";
+var DEFAULT_EVENT_PREFIX = "@@es/evt/";
+var SEQ_WIDTH = 16;
+function eventKey(prefix, seq) {
+  return prefix + String(seq).padStart(SEQ_WIDTH, "0");
+}
+var defaultParse = (raw) => raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+var defaultParseEvent = (raw) => raw !== null && typeof raw === "object" && !Array.isArray(raw) && typeof raw.type === "string" ? raw : null;
+function doEventSourcedStore(storage, machine, ctx, opts = {}) {
+  const snapshotEvery = opts.snapshotEvery ?? 100;
+  if (snapshotEvery < 1 || !Number.isInteger(snapshotEvery)) {
+    throw new Error(
+      `@demlik/tea/do: snapshotEvery must be an integer >= 1, got ${snapshotEvery}`
+    );
+  }
+  const parse = opts.parse ?? defaultParse;
+  const parseEvent = opts.parseEvent ?? defaultParseEvent;
+  const snapshotKey = opts.keys?.snapshot ?? DEFAULT_SNAPSHOT_KEY;
+  const metaKey = opts.keys?.meta ?? DEFAULT_META_KEY;
+  const eventPrefix = opts.keys?.eventPrefix ?? DEFAULT_EVENT_PREFIX;
+  let lastSeq = null;
+  let snapshotSeq = 0;
+  let latestState = null;
+  let readyFired = false;
+  async function readMeta() {
+    const raw = await storage.get(metaKey);
+    if (raw === void 0 || raw === null) return 0;
+    const meta = JSON.parse(raw);
+    return typeof meta.lastSeq === "number" ? meta.lastSeq : 0;
+  }
+  async function readSnapshot() {
+    const raw = await storage.get(snapshotKey);
+    if (raw === void 0 || raw === null) return { state: null, seq: 0 };
+    const cell = JSON.parse(raw);
+    const parsed = parse(cell.state);
+    if (parsed === null) return { state: null, seq: 0 };
+    const seq = typeof cell.seq === "number" ? cell.seq : 0;
+    return { state: parsed, seq };
+  }
+  async function* readEvents(range = {}) {
+    const fromSeq = range.fromSeq ?? Number.NEGATIVE_INFINITY;
+    const toSeq = range.toSeq ?? Number.POSITIVE_INFINITY;
+    const rows = await storage.list({ prefix: eventPrefix });
+    for (const [key, value] of rows) {
+      const seq = Number(key.slice(eventPrefix.length));
+      if (!Number.isFinite(seq) || seq < fromSeq || seq > toSeq) continue;
+      const decoded = parseEvent(JSON.parse(value));
+      if (decoded !== null) yield { seq, event: decoded };
+    }
+  }
+  async function readLog(afterSeq) {
+    const events = [];
+    for await (const { event } of readEvents({ fromSeq: afterSeq + 1 })) {
+      events.push(event);
+    }
+    return events;
+  }
+  const store = {
     async load() {
-      const raw = await storage.get(key);
-      if (raw === void 0 || raw === null) return null;
-      return JSON.parse(raw);
+      const { state: snapshot, seq: snapSeq } = await readSnapshot();
+      snapshotSeq = snapSeq;
+      lastSeq = await readMeta();
+      const events = await readLog(snapSeq);
+      const { state } = replay(machine, {
+        msgs: events,
+        ctx,
+        loaded: snapshot
+      });
+      if (!readyFired) {
+        readyFired = true;
+        opts.onReady?.(state);
+      }
+      return state;
     },
     async save(state) {
-      await storage.put(key, JSON.stringify(state));
+      latestState = state;
     },
     migrate(raw) {
       return parse(raw);
     }
   };
+  async function writeSnapshot(seq, state) {
+    const cell = { seq, state };
+    await storage.put(snapshotKey, JSON.stringify(cell));
+    snapshotSeq = seq;
+  }
+  async function append(msg) {
+    if (lastSeq === null) lastSeq = await readMeta();
+    const seq = lastSeq + 1;
+    lastSeq = seq;
+    await storage.put(eventKey(eventPrefix, seq), JSON.stringify(msg));
+    await storage.put(
+      metaKey,
+      JSON.stringify({ lastSeq: seq })
+    );
+    if (seq - snapshotSeq >= snapshotEvery && latestState !== null) {
+      await writeSnapshot(seq, latestState);
+    }
+  }
+  async function snapshotNow() {
+    if (lastSeq === null) lastSeq = await readMeta();
+    if (latestState === null || lastSeq <= snapshotSeq) return false;
+    await writeSnapshot(lastSeq, latestState);
+    return true;
+  }
+  return { store, append, snapshotNow, readEvents };
 }
-function doSubscribe() {
+
+// src/do/host.ts
+function deferredGateway() {
+  const pending = /* @__PURE__ */ new Map();
   return {
-    do_alarm: (sub, ctx, _dispatch) => {
-      ctx.alarmRegistry.set(sub.id, { firesAt: sub.firesAt, msg: sub.msg });
-      const earliest = earliestFiresAt(ctx.alarmRegistry);
-      if (earliest !== null) {
-        ctx.state.storage.setAlarm(earliest).catch((err) => console.error("[tea-do] setAlarm failed", err));
+    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 () => {
-        ctx.alarmRegistry.delete(sub.id);
-        const nextEarliest = earliestFiresAt(ctx.alarmRegistry);
-        if (nextEarliest === null) {
-          ctx.state.storage.deleteAlarm().catch((err) => console.error("[tea-do] deleteAlarm failed", err));
-        } else {
-          ctx.state.storage.setAlarm(nextEarliest).catch((err) => console.error("[tea-do] setAlarm failed", err));
+      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);
+  }
+}
+async function bootResume(booting, port, now = Date.now) {
+  const runtime = await booting.ready;
+  if (port.isResumable(runtime.getState())) {
+    await runtime.dispatch(port.resumeMsg(now()));
+  }
+}
+function agentIsResumable(state) {
+  return status(state).kind === "suspended";
+}
+async function autoBoot(booting, now = Date.now) {
+  await bootResume(
+    booting,
+    { isResumable: agentIsResumable, resumeMsg: agentBootMsg },
+    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()) {
+    reissue(effect.callId);
+    reemitted.push(effect.callId);
+  }
+  return reemitted;
+}
+function sseHub() {
+  const sinks = /* @__PURE__ */ new Set();
+  const encoder = new TextEncoder();
+  return {
+    emit(event) {
+      for (const sink of sinks) {
+        try {
+          sink(event);
+        } catch {
         }
-      };
+      }
+    },
+    open() {
+      let sink;
+      const stream = new ReadableStream({
+        start: (controller) => {
+          sink = (event) => {
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify(event)}
+
+`)
+            );
+          };
+          sinks.add(sink);
+        },
+        cancel: () => {
+          sinks.delete(sink);
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache",
+          connection: "keep-alive"
+        }
+      });
     },
-    do_ws: (sub, ctx, _dispatch) => {
-      ctx.wsRegistry.set(sub.id, { socketId: sub.socketId, msg: sub.msg });
+    register(sink) {
+      sinks.add(sink);
       return () => {
-        ctx.wsRegistry.delete(sub.id);
+        sinks.delete(sink);
       };
     }
   };
 }
-function earliestFiresAt(registry) {
-  let earliest = null;
-  for (const { firesAt } of registry.values()) {
-    if (earliest === null || firesAt < earliest) earliest = firesAt;
+function sseProjection(hub, toEvent, id = {}) {
+  return {
+    id: { name: id.name ?? "sse", key: id.key ?? "main" },
+    initial: null,
+    apply(_view, update) {
+      return toEvent(update.msg, update.model);
+    },
+    emit(view) {
+      if (view !== null) hub.emit(view);
+    }
+  };
+}
+function sseFromAgentEvents(runtime, hub, toFrame) {
+  const push = (event) => {
+    const frame = toFrame(event);
+    if (frame !== null) hub.emit(frame);
+  };
+  const offs = [
+    runtime.on("TurnSettled", push),
+    runtime.on("ToolSettled", push),
+    runtime.on("RunDone", push)
+  ];
+  return () => {
+    for (const off of offs) off();
+  };
+}
+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;
+    const booting = run(config.buildMachine(), {
+      ctx: config.ctx,
+      store: config.store,
+      events: agentEvents(),
+      terminal: isTerminal
+    });
+    sseFromAgentEvents(booting, sse, config.toSseFrame);
+    await autoBoot(booting, now);
+    cached = await booting.ready;
+    return cached;
+  }
+  return {
+    runtime,
+    async status() {
+      return status((await runtime()).getState());
+    },
+    async result() {
+      return (await runtime()).result();
+    },
+    sse,
+    async reset() {
+      if (cached === null) return;
+      await cached.stop();
+      cached = null;
+    }
+  };
+}
+
+// src/do/idempotent-effect.ts
+function emptyApplied() {
+  return /* @__PURE__ */ new Set();
+}
+function applyAppliedEvent(applied, event) {
+  switch (event.type) {
+    case "effect_applied": {
+      if (applied.has(event.key)) return applied;
+      const next = new Set(applied);
+      next.add(event.key);
+      return next;
+    }
+    case "effect_forgotten": {
+      if (!applied.has(event.key)) return applied;
+      const next = new Set(applied);
+      next.delete(event.key);
+      return next;
+    }
+  }
+}
+function foldApplied(events) {
+  let applied = emptyApplied();
+  for (const event of events) applied = applyAppliedEvent(applied, event);
+  return applied;
+}
+function isApplied(applied, key) {
+  return applied.has(key);
+}
+function idempotentEffect(key, fn) {
+  return { key, fn };
+}
+function appliedEffects(restore) {
+  let mirror = restore?.events ? foldApplied(restore.events) : emptyApplied();
+  return {
+    async run(effect) {
+      if (mirror.has(effect.key)) {
+        return { ran: false, key: effect.key };
+      }
+      const result = await effect.fn();
+      const event = { type: "effect_applied", key: effect.key };
+      mirror = applyAppliedEvent(mirror, event);
+      return { ran: true, key: effect.key, result, event };
+    },
+    forget(key) {
+      const event = { type: "effect_forgotten", key };
+      mirror = applyAppliedEvent(mirror, event);
+      return { event };
+    },
+    applied() {
+      return mirror;
+    },
+    isApplied(key) {
+      return mirror.has(key);
+    }
+  };
+}
+
+// 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}`;
+}
+function runProjection(projection, startOffset = 0) {
+  let view = projection.initial;
+  let storedOffset = startOffset;
+  return {
+    id: projection.id,
+    view: () => view,
+    offset: () => storedOffset,
+    present(update) {
+      if (update.offset <= storedOffset) return false;
+      const next = projection.apply(view, update);
+      view = next;
+      storedOffset = update.offset;
+      projection.emit(next);
+      return true;
+    },
+    reset() {
+      view = projection.initial;
+      storedOffset = 0;
+    }
+  };
+}
+function projectionRegistry() {
+  const runners = /* @__PURE__ */ new Set();
+  let counter = -1;
+  return {
+    register(projection, startOffset) {
+      const runner = runProjection(projection, startOffset);
+      runners.add(runner);
+      return runner;
+    },
+    dispatch(msg, model) {
+      const offset = ++counter;
+      const update = { msg, model, offset };
+      for (const runner of runners) {
+        try {
+          runner.present(update);
+        } catch {
+        }
+      }
+      return offset;
+    },
+    offset: () => counter,
+    runners: () => [...runners]
+  };
+}
+function driveProjections(registry, runtime) {
+  const unboot = runtime.onBoot((model) => {
+    registry.dispatch(null, model);
+  });
+  const unobserve = runtime.observe((msg, model) => {
+    registry.dispatch(msg, model);
+  });
+  return () => {
+    unobserve();
+    unboot();
+  };
+}
+function rebuildProjection(projection, updates) {
+  const runner = runProjection(projection, 0);
+  updates.forEach((u, i) => {
+    runner.present({ msg: u.msg, model: u.model, offset: i + 1 });
+  });
+  return runner;
+}
+
+// src/do/step-host.ts
+function mintRunToken(randomBytes = defaultRandomBytes) {
+  const bytes = randomBytes(32);
+  let hex = "";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function defaultRandomBytes(n) {
+  const out = new Uint8Array(n);
+  crypto.getRandomValues(out);
+  return out;
+}
+function constantTimeEqual(a, b) {
+  const lengthMatches = a.length === b.length;
+  const rhs = lengthMatches ? b : a;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ rhs.charCodeAt(i);
+  }
+  return diff === 0 && lengthMatches;
+}
+var DEFAULT_GIVE_UP_MS = 5 * 6e4;
+function stepHost(ctx, engine, config = {}) {
+  const giveUpAfterMs = config.giveUpAfterMs ?? DEFAULT_GIVE_UP_MS;
+  const intake = createIntake({
+    keyOf: (posted) => posted.callId
+  });
+  let intakeState = intake.init();
+  async function handle(request, now) {
+    const stored = await engine.tokenFor(request.runId);
+    if (stored === null) {
+      return { status: 404, body: { error: "unknown run" } };
+    }
+    if (!constantTimeEqual(request.token, stored)) {
+      return { status: 401, body: { error: "invalid token" } };
+    }
+    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;
+        }
+      }
+    }
+    const next = await engine.nextStep(request.runId);
+    if (next === null) {
+      const output = await engine.terminalOutput(request.runId);
+      return { status: 200, body: { done: true, output } };
+    }
+    return { status: 200, body: { done: false, step: next } };
   }
-  return earliest;
+  return { handle };
+}
+async function runStepLoop(token, runId, transport, execute, config) {
+  const policy = config.retry ?? defaultRetryPolicy;
+  const now = config.now ?? Date.now;
+  const sleep = config.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const rng = config.rng;
+  const executed = /* @__PURE__ */ new Map();
+  let posted = null;
+  for (; ; ) {
+    if (now() >= config.deadlineMs) return { kind: "deadline_exceeded" };
+    let response;
+    let retry = initRetry();
+    for (; ; ) {
+      try {
+        response = await transport({ token, runId, posted });
+        break;
+      } catch (error) {
+        retry = recordFailure(retry, error);
+        if (!shouldRetry(retry, policy)) return { kind: "gave_up", error };
+        if (now() >= config.deadlineMs) return { kind: "deadline_exceeded" };
+        await sleep(nextDelayMs(retry, policy, rng));
+      }
+    }
+    if (response.done) return { kind: "done", output: response.output };
+    const step = response.step;
+    const cached = executed.get(step.callId);
+    const result = cached !== void 0 ? cached : await execute(step);
+    if (cached === void 0) executed.set(step.callId, result);
+    posted = { callId: step.callId, result };
+  }
+}
+
+// src/do/index.ts
+var DEFAULT_STATE_KEY = "@@state";
+function doStore(storage, parse, keyOrOptions = DEFAULT_STATE_KEY) {
+  const options = typeof keyOrOptions === "string" ? { key: keyOrOptions } : keyOrOptions;
+  const key = options.key ?? DEFAULT_STATE_KEY;
+  const serialize = options.serialize ?? ((state) => state);
+  return {
+    async load() {
+      const raw = await storage.get(key);
+      if (raw === void 0 || raw === null) return null;
+      return JSON.parse(raw);
+    },
+    async save(state) {
+      await storage.put(key, JSON.stringify(serialize(state)));
+    },
+    migrate(raw) {
+      return parse(raw);
+    }
+  };
 }
 
-export { doStore, doSubscribe };
+export { WS_READY_STATE_OPEN, acceptCommandSocket, acceptDurableCommandSocket, acceptPresenceSocket, agentIsResumable, appliedEffects, applyAppliedEvent, autoBoot, bootResume, broadcast, broadcastFrame, broadcastHibernatable, constantTimeEqual, createAgentHost, deferredGateway, doEventSourcedStore, doStore, driveProjections, durableCommandCarrier, durableDeferredGateway, durableTimer, emptyApplied, foldApplied, idempotentEffect, isApplied, mintRunToken, presenceCount, projectionIdString, projectionRegistry, rebuildProjection, registerHibernatableSocket, reissueSurvivingEffects, runProjection, runStepLoop, sseFromAgentEvents, sseHub, sseProjection, stepHost };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map