rivetkit 2.1.5 → 2.1.6-rc.1

package/dist/tsup/chunk-DK46YYCJ.js

@@ -0,0 +1,1486 @@
+import {
+  WORKFLOW_GUARD_KV_KEY,
+  workflow
+} from "./chunk-SVHJSM2E.js";
+import {
+  actor,
+  event,
+  queue
+} from "./chunk-UQZRMTM3.js";
+import {
+  db
+} from "./chunk-MLK3GY6P.js";
+import {
+  getLogger,
+  promiseWithResolvers
+} from "./chunk-VWYO36X4.js";
+
+// src/driver-test-suite/log.ts
+function logger() {
+  return getLogger("test-suite");
+}
+
+// fixtures/driver-test-suite/hibernation.ts
+var HIBERNATION_SLEEP_TIMEOUT = 500;
+var hibernationActor = actor({
+  state: {
+    sleepCount: 0,
+    wakeCount: 0
+  },
+  createConnState: (c) => {
+    return {
+      count: 0,
+      connectCount: 0,
+      disconnectCount: 0
+    };
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onConnect: (c, conn) => {
+    conn.state.connectCount += 1;
+  },
+  onDisconnect: (c, conn) => {
+    conn.state.disconnectCount += 1;
+  },
+  actions: {
+    // Basic RPC that returns a simple value
+    ping: (c) => {
+      return "pong";
+    },
+    // Increment the connection's count
+    connIncrement: (c) => {
+      c.conn.state.count += 1;
+      return c.conn.state.count;
+    },
+    // Get the connection's count
+    getConnCount: (c) => {
+      return c.conn.state.count;
+    },
+    // Get the connection's lifecycle counts
+    getConnLifecycleCounts: (c) => {
+      return {
+        connectCount: c.conn.state.connectCount,
+        disconnectCount: c.conn.state.disconnectCount
+      };
+    },
+    // Get all connection IDs
+    getConnectionIds: (c) => {
+      return c.conns.entries().map((x) => x[0]).toArray();
+    },
+    // Get actor sleep/wake counts
+    getActorCounts: (c) => {
+      return {
+        sleepCount: c.state.sleepCount,
+        wakeCount: c.state.wakeCount
+      };
+    },
+    // Trigger sleep
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: HIBERNATION_SLEEP_TIMEOUT
+  }
+});
+
+// fixtures/driver-test-suite/sleep.ts
+var SLEEP_TIMEOUT = 1e3;
+var sleep = actor({
+  state: { startCount: 0, sleepCount: 0 },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
+    },
+    setAlarm: async (c, duration) => {
+      await c.schedule.after(duration, "onAlarm");
+    },
+    onAlarm: (c) => {
+      c.log.info("alarm called");
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithLongRpc = actor({
+  state: { startCount: 0, sleepCount: 0 },
+  createVars: () => ({}),
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
+    },
+    longRunningRpc: async (c) => {
+      c.log.info("starting long running rpc");
+      c.vars.longRunningResolve = promiseWithResolvers(
+        (reason) => c.log.warn({
+          msg: "unhandled long running rpc rejection",
+          reason
+        })
+      );
+      c.broadcast("waiting");
+      await c.vars.longRunningResolve.promise;
+      c.log.info("finished long running rpc");
+    },
+    finishLongRunningRpc: (c) => {
+      var _a;
+      return (_a = c.vars.longRunningResolve) == null ? void 0 : _a.resolve();
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithWaitUntilMessage = actor({
+  state: {
+    startCount: 0,
+    sleepCount: 0,
+    waitUntilMessageCount: 0
+  },
+  events: {
+    sleeping: event()
+  },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    triggerSleep: (c) => {
+      c.waitUntil(
+        new Promise((resolve) => {
+          setTimeout(() => {
+            c.state.waitUntilMessageCount += 1;
+            c.conn.send("sleeping", {
+              sleepCount: c.state.sleepCount,
+              startCount: c.state.startCount
+            });
+            resolve();
+          }, 10);
+        })
+      );
+      c.sleep();
+    },
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        waitUntilMessageCount: c.state.waitUntilMessageCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawHttp = actor({
+  state: { startCount: 0, sleepCount: 0, requestCount: 0 },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onRequest: async (c, request) => {
+    c.state.requestCount += 1;
+    const url = new URL(request.url);
+    if (url.pathname === "/long-request") {
+      const duration = parseInt(
+        url.searchParams.get("duration") || "1000"
+      );
+      c.log.info({ msg: "starting long fetch request", duration });
+      await new Promise((resolve) => setTimeout(resolve, duration));
+      c.log.info("finished long fetch request");
+      return new Response(JSON.stringify({ completed: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        requestCount: c.state.requestCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawWebSocket = actor({
+  state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onWebSocket: (c, websocket) => {
+    c.state.connectionCount += 1;
+    c.log.info({
+      msg: "websocket connected",
+      connectionCount: c.state.connectionCount
+    });
+    websocket.send(
+      JSON.stringify({
+        type: "connected",
+        connectionCount: c.state.connectionCount
+      })
+    );
+    websocket.addEventListener("message", (event2) => {
+      const data = event2.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "getCounts") {
+            websocket.send(
+              JSON.stringify({
+                type: "counts",
+                startCount: c.state.startCount,
+                sleepCount: c.state.sleepCount,
+                connectionCount: c.state.connectionCount
+              })
+            );
+          } else if (parsed.type === "keepAlive") {
+            websocket.send(JSON.stringify({ type: "ack" }));
+          }
+        } catch {
+          websocket.send(data);
+        }
+      }
+    });
+    websocket.addEventListener("close", () => {
+      c.state.connectionCount -= 1;
+      c.log.info({
+        msg: "websocket disconnected",
+        connectionCount: c.state.connectionCount
+      });
+    });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        connectionCount: c.state.connectionCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithNoSleepOption = actor({
+  state: { startCount: 0, sleepCount: 0 },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT,
+    noSleep: true
+  }
+});
+var sleepWithPreventSleep = actor({
+  state: {
+    startCount: 0,
+    sleepCount: 0,
+    preventSleepOnWake: false
+  },
+  onWake: (c) => {
+    c.state.startCount += 1;
+    c.setPreventSleep(c.state.preventSleepOnWake);
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    getStatus: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        preventSleep: c.preventSleep,
+        preventSleepOnWake: c.state.preventSleepOnWake
+      };
+    },
+    setPreventSleep: (c, prevent) => {
+      c.setPreventSleep(prevent);
+      return c.preventSleep;
+    },
+    setPreventSleepOnWake: (c, prevent) => {
+      c.state.preventSleepOnWake = prevent;
+      return c.state.preventSleepOnWake;
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+
+// fixtures/driver-test-suite/queue.ts
+var queueSchemas = {
+  greeting: queue(),
+  self: queue(),
+  a: queue(),
+  b: queue(),
+  c: queue(),
+  one: queue(),
+  two: queue(),
+  missing: queue(),
+  abort: queue(),
+  tasks: queue(),
+  timeout: queue(),
+  nowait: queue(),
+  twice: queue()
+};
+var queueActor = actor({
+  state: {},
+  queues: queueSchemas,
+  actions: {
+    receiveOne: async (c, name, opts) => {
+      const message = await c.queue.next({
+        names: [name],
+        timeout: opts == null ? void 0 : opts.timeout
+      });
+      if (!message) {
+        return null;
+      }
+      return { name: message.name, body: message.body };
+    },
+    receiveMany: async (c, names, opts) => {
+      const messages = await c.queue.nextBatch({
+        names,
+        count: opts == null ? void 0 : opts.count,
+        timeout: opts == null ? void 0 : opts.timeout
+      });
+      return messages.map((message) => ({
+        name: message.name,
+        body: message.body
+      }));
+    },
+    receiveRequest: async (c, request) => {
+      const messages = await c.queue.nextBatch(request);
+      return messages.map((message) => ({
+        name: message.name,
+        body: message.body
+      }));
+    },
+    tryReceiveMany: async (c, request) => {
+      const messages = await c.queue.tryNextBatch(request);
+      return messages.map((message) => ({
+        name: message.name,
+        body: message.body
+      }));
+    },
+    receiveWithIterator: async (c, name) => {
+      for await (const message of c.queue.iter({ names: [name] })) {
+        return { name: message.name, body: message.body };
+      }
+      return null;
+    },
+    receiveWithAsyncIterator: async (c) => {
+      for await (const message of c.queue.iter()) {
+        return { name: message.name, body: message.body };
+      }
+      return null;
+    },
+    sendToSelf: async (c, name, body) => {
+      const client = c.client();
+      const handle = client.queueActor.getForId(c.actorId);
+      await handle.send(name, body);
+      return true;
+    },
+    waitForAbort: async (c) => {
+      setTimeout(() => {
+        c.destroy();
+      }, 10);
+      await c.queue.next({ names: ["abort"], timeout: 1e4 });
+      return true;
+    },
+    waitForSignalAbort: async (c) => {
+      const controller = new AbortController();
+      controller.abort();
+      try {
+        await c.queue.next({
+          names: ["abort"],
+          timeout: 1e4,
+          signal: controller.signal
+        });
+        return { ok: false };
+      } catch (error) {
+        const actorError = error;
+        return { group: actorError.group, code: actorError.code };
+      }
+    },
+    waitForActorAbortWithSignal: async (c) => {
+      const controller = new AbortController();
+      setTimeout(() => {
+        c.destroy();
+      }, 10);
+      try {
+        await c.queue.next({
+          names: ["abort"],
+          timeout: 1e4,
+          signal: controller.signal
+        });
+        return { ok: false };
+      } catch (error) {
+        const actorError = error;
+        return { group: actorError.group, code: actorError.code };
+      }
+    },
+    iterWithSignalAbort: async (c) => {
+      const controller = new AbortController();
+      controller.abort();
+      for await (const _message of c.queue.iter({
+        names: ["abort"],
+        signal: controller.signal
+      })) {
+        return { ok: false };
+      }
+      return { ok: true };
+    },
+    receiveAndComplete: async (c, name) => {
+      const message = await c.queue.next({
+        names: [name],
+        completable: true
+      });
+      if (!message) {
+        return null;
+      }
+      await message.complete({ echo: message.body });
+      return { name: message.name, body: message.body };
+    },
+    receiveWithoutComplete: async (c, name) => {
+      const message = await c.queue.next({
+        names: [name],
+        completable: true
+      });
+      if (!message) {
+        return null;
+      }
+      return { name: message.name, body: message.body };
+    },
+    receiveManualThenNextWithoutComplete: async (c, name) => {
+      const message = await c.queue.next({
+        names: [name],
+        completable: true
+      });
+      if (!message) {
+        return { ok: false, reason: "no_message" };
+      }
+      try {
+        await c.queue.next({ names: [name], timeout: 0 });
+        c.destroy();
+        return { ok: false, reason: "next_succeeded" };
+      } catch (error) {
+        c.destroy();
+        const actorError = error;
+        return { group: actorError.group, code: actorError.code };
+      }
+    },
+    receiveAndCompleteTwice: async (c, name) => {
+      const message = await c.queue.next({
+        names: [name],
+        completable: true
+      });
+      if (!message) {
+        return null;
+      }
+      await message.complete({ ok: true });
+      try {
+        await message.complete({ ok: true });
+        return { ok: false };
+      } catch (error) {
+        const actorError = error;
+        return { group: actorError.group, code: actorError.code };
+      }
+    },
+    receiveWithoutCompleteMethod: async (c, name) => {
+      const message = await c.queue.next({
+        names: [name],
+        completable: true
+      });
+      return {
+        hasComplete: message !== void 0 && typeof message.complete === "function"
+      };
+    }
+  }
+});
+var queueLimitedActor = actor({
+  state: {},
+  queues: {
+    message: queue(),
+    oversize: queue()
+  },
+  actions: {},
+  options: {
+    maxQueueSize: 1,
+    maxQueueMessageSize: 64
+  }
+});
+var MANY_QUEUE_NAMES = Array.from(
+  { length: 32 },
+  (_, i) => `cmd.${i}`
+);
+var manyQueueSchemas = Object.fromEntries(
+  MANY_QUEUE_NAMES.map((name) => [
+    name,
+    queue()
+  ])
+);
+var manyQueueChildActor = actor({
+  queues: manyQueueSchemas,
+  actions: {
+    ping: (c) => ({ label: c.state.label, pong: true }),
+    getSnapshot: (c) => c.state
+  },
+  createState: (_c, label) => ({
+    label,
+    started: false,
+    processed: []
+  }),
+  run: async (c) => {
+    c.state.started = true;
+    for await (const msg of c.queue.iter({
+      names: [...MANY_QUEUE_NAMES],
+      completable: true
+    })) {
+      c.state.processed.push(msg.name);
+      await msg.complete({
+        ok: true,
+        index: msg.body.index
+      });
+    }
+  }
+});
+var manyQueueActionParentActor = actor({
+  state: {
+    spawned: []
+  },
+  actions: {
+    spawnChild: async (c, key) => {
+      const client = c.client();
+      await client.manyQueueChildActor.getOrCreate([key], {
+        createWithInput: key
+      });
+      c.state.spawned.push(key);
+      return { key };
+    },
+    getSpawned: (c) => c.state.spawned
+  }
+});
+var manyQueueRunParentActor = actor({
+  state: {
+    spawned: []
+  },
+  queues: {
+    spawn: queue()
+  },
+  actions: {
+    queueSpawn: async (c, key) => {
+      await c.queue.send("spawn", { key });
+      return { queued: true };
+    },
+    getSpawned: (c) => c.state.spawned
+  },
+  run: async (c) => {
+    for await (const msg of c.queue.iter({
+      names: ["spawn"],
+      completable: true
+    })) {
+      const client = c.client();
+      await client.manyQueueChildActor.getOrCreate([msg.body.key], {
+        createWithInput: msg.body.key
+      });
+      c.state.spawned.push(msg.body.key);
+      await msg.complete({ ok: true });
+    }
+  }
+});
+
+// fixtures/driver-test-suite/run.ts
+var RUN_SLEEP_TIMEOUT = 1e3;
+var runWithTicks = actor({
+  state: {
+    tickCount: 0,
+    lastTickAt: 0,
+    runStarted: false,
+    runExited: false
+  },
+  run: async (c) => {
+    c.state.runStarted = true;
+    c.log.info("run handler started");
+    while (!c.aborted) {
+      c.state.tickCount += 1;
+      c.state.lastTickAt = Date.now();
+      c.log.info({ msg: "tick", tickCount: c.state.tickCount });
+      await new Promise((resolve) => {
+        const timeout = setTimeout(resolve, 50);
+        c.abortSignal.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timeout);
+            resolve();
+          },
+          { once: true }
+        );
+      });
+    }
+    c.state.runExited = true;
+    c.log.info("run handler exiting gracefully");
+  },
+  actions: {
+    getState: (c) => ({
+      tickCount: c.state.tickCount,
+      lastTickAt: c.state.lastTickAt,
+      runStarted: c.state.runStarted,
+      runExited: c.state.runExited
+    })
+  },
+  options: {
+    sleepTimeout: RUN_SLEEP_TIMEOUT,
+    runStopTimeout: 1e3
+  }
+});
+var runWithQueueConsumer = actor({
+  state: {
+    messagesReceived: [],
+    runStarted: false,
+    wakeCount: 0
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  run: async (c) => {
+    c.state.runStarted = true;
+    c.log.info("run handler started, waiting for messages");
+    while (!c.aborted) {
+      const message = await c.queue.next({ names: ["messages"] });
+      if (message) {
+        c.log.info({ msg: "received message", body: message.body });
+        c.state.messagesReceived.push({
+          name: message.name,
+          body: message.body
+        });
+      }
+    }
+    c.log.info("run handler exiting gracefully");
+  },
+  actions: {
+    getState: (c) => ({
+      messagesReceived: c.state.messagesReceived,
+      runStarted: c.state.runStarted,
+      wakeCount: c.state.wakeCount
+    }),
+    sendMessage: async (c, body) => {
+      const client = c.client();
+      const handle = client.runWithQueueConsumer.getForId(c.actorId);
+      await handle.send("messages", body);
+      return true;
+    }
+  },
+  options: {
+    sleepTimeout: RUN_SLEEP_TIMEOUT,
+    runStopTimeout: 1e3
+  }
+});
+var runWithEarlyExit = actor({
+  state: {
+    runStarted: false,
+    destroyCalled: false,
+    sleepCount: 0,
+    wakeCount: 0
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  run: async (c) => {
+    c.state.runStarted = true;
+    c.log.info("run handler started, will exit after delay");
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    c.log.info("run handler exiting early");
+  },
+  onDestroy: (c) => {
+    c.state.destroyCalled = true;
+  },
+  actions: {
+    getState: (c) => ({
+      runStarted: c.state.runStarted,
+      destroyCalled: c.state.destroyCalled,
+      sleepCount: c.state.sleepCount,
+      wakeCount: c.state.wakeCount
+    })
+  },
+  options: {
+    sleepTimeout: RUN_SLEEP_TIMEOUT
+  }
+});
+var runWithError = actor({
+  state: {
+    runStarted: false,
+    destroyCalled: false,
+    sleepCount: 0,
+    wakeCount: 0
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  run: async (c) => {
+    c.state.runStarted = true;
+    c.log.info("run handler started, will throw error");
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    throw new Error("intentional error in run handler");
+  },
+  onDestroy: (c) => {
+    c.state.destroyCalled = true;
+  },
+  actions: {
+    getState: (c) => ({
+      runStarted: c.state.runStarted,
+      destroyCalled: c.state.destroyCalled,
+      sleepCount: c.state.sleepCount,
+      wakeCount: c.state.wakeCount
+    })
+  },
+  options: {
+    sleepTimeout: RUN_SLEEP_TIMEOUT
+  }
+});
+var runWithoutHandler = actor({
+  state: {
+    wakeCount: 0
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  actions: {
+    getState: (c) => ({
+      wakeCount: c.state.wakeCount
+    })
+  },
+  options: {
+    sleepTimeout: RUN_SLEEP_TIMEOUT
+  }
+});
+
+// fixtures/driver-test-suite/workflow.ts
+import { Loop } from "@rivetkit/workflow-engine";
+var WORKFLOW_QUEUE_NAME = "workflow-default";
+var WORKFLOW_NESTED_QUEUE_NAME = "workflow-nested";
+var workflowCounterActor = actor({
+  state: {
+    runCount: 0,
+    guardTriggered: false,
+    history: []
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("counter", async (loopCtx) => {
+      try {
+        loopCtx.state;
+      } catch {
+      }
+      await loopCtx.step("increment", async () => {
+        incrementWorkflowCounter(loopCtx);
+      });
+      await loopCtx.sleep("idle", 25);
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: async (c) => {
+      const guardFlag = await c.kv.get(WORKFLOW_GUARD_KV_KEY);
+      if (guardFlag === "true") {
+        c.state.guardTriggered = true;
+      }
+      return c.state;
+    }
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowQueueActor = actor({
+  state: {
+    received: []
+  },
+  queues: {
+    [WORKFLOW_QUEUE_NAME]: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("queue", async (loopCtx) => {
+      const message = await loopCtx.queue.next("queue-wait", {
+        names: [WORKFLOW_QUEUE_NAME],
+        completable: true
+      });
+      if (!message.complete) {
+        return Loop.continue(void 0);
+      }
+      const complete = message.complete;
+      await loopCtx.step("store-message", async () => {
+        await storeWorkflowQueueMessage(
+          loopCtx,
+          message.body,
+          complete
+        );
+      });
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getMessages: (c) => c.state.received,
+    sendAndWait: async (c, payload) => {
+      const client = c.client();
+      const handle = client.workflowQueueActor.getForId(c.actorId);
+      return await handle.send(WORKFLOW_QUEUE_NAME, payload, {
+        wait: true,
+        timeout: 1e3
+      });
+    }
+  }
+});
+var workflowNestedLoopActor = actor({
+  state: {
+    processed: []
+  },
+  queues: {
+    [WORKFLOW_NESTED_QUEUE_NAME]: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("command-loop", async (loopCtx) => {
+      var _a;
+      const message = await loopCtx.queue.next("wait", {
+        names: [WORKFLOW_NESTED_QUEUE_NAME],
+        completable: true
+      });
+      let itemIndex = 0;
+      await loopCtx.loop("process-items", async (subLoopCtx) => {
+        const item = message.body.items[itemIndex];
+        if (item === void 0) {
+          return Loop.break(void 0);
+        }
+        await subLoopCtx.step(`process-item-${itemIndex}`, async () => {
+          subLoopCtx.state.processed.push(item);
+        });
+        itemIndex += 1;
+        return Loop.continue(void 0);
+      });
+      await ((_a = message.complete) == null ? void 0 : _a.call(message, { processed: message.body.items.length }));
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowNestedJoinActor = actor({
+  state: {
+    processed: []
+  },
+  queues: {
+    [WORKFLOW_NESTED_QUEUE_NAME]: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("command-loop", async (loopCtx) => {
+      var _a;
+      const message = await loopCtx.queue.next("wait", {
+        names: [WORKFLOW_NESTED_QUEUE_NAME],
+        completable: true
+      });
+      await loopCtx.join(
+        "process-items",
+        Object.fromEntries(
+          message.body.items.map((item, index) => [
+            `item-${index}`,
+            {
+              run: async (branchCtx) => await branchCtx.step(
+                `process-item-${index}`,
+                async () => {
+                  branchCtx.state.processed.push(item);
+                  return item;
+                }
+              )
+            }
+          ])
+        )
+      );
+      await ((_a = message.complete) == null ? void 0 : _a.call(message, { processed: message.body.items.length }));
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowNestedRaceActor = actor({
+  state: {
+    processed: []
+  },
+  queues: {
+    [WORKFLOW_NESTED_QUEUE_NAME]: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("command-loop", async (loopCtx) => {
+      var _a;
+      const message = await loopCtx.queue.next("wait", {
+        names: [WORKFLOW_NESTED_QUEUE_NAME],
+        completable: true
+      });
+      const item = message.body.items[0];
+      if (item !== void 0) {
+        await loopCtx.race("process-item", [
+          {
+            name: "fast",
+            run: async (raceCtx) => await raceCtx.step("process-fast", async () => {
+              raceCtx.state.processed.push(item);
+              return item;
+            })
+          },
+          {
+            name: "slow",
+            run: async (raceCtx) => {
+              await new Promise((resolve) => {
+                if (raceCtx.abortSignal.aborted) {
+                  resolve();
+                  return;
+                }
+                raceCtx.abortSignal.addEventListener(
+                  "abort",
+                  () => resolve(),
+                  { once: true }
+                );
+              });
+              return "slow";
+            }
+          }
+        ]);
+      }
+      await ((_a = message.complete) == null ? void 0 : _a.call(message, { processed: message.body.items.length }));
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowSpawnChildActor = actor({
+  createState: (_c, input) => ({
+    label: input ?? "",
+    started: false,
+    processed: []
+  }),
+  queues: {
+    work: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.step("mark-started", async () => {
+      ctx.state.started = true;
+    });
+    await ctx.loop("cmd-loop", async (loopCtx) => {
+      var _a;
+      const message = await loopCtx.queue.next(
+        "wait-cmd",
+        {
+          names: ["work"],
+          completable: true
+        }
+      );
+      await loopCtx.step("process-cmd", async () => {
+        loopCtx.state.processed.push(message.body.task);
+      });
+      await ((_a = message.complete) == null ? void 0 : _a.call(message, { ok: true }));
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowSpawnParentActor = actor({
+  state: {
+    results: []
+  },
+  queues: {
+    spawn: queue()
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("parent-loop", async (loopCtx) => {
+      var _a;
+      const message = await loopCtx.queue.next(
+        "wait-parent",
+        {
+          names: ["spawn"],
+          completable: true
+        }
+      );
+      await loopCtx.step("spawn-child", async () => {
+        try {
+          const client = loopCtx.client();
+          const handle = client.workflowSpawnChildActor.getOrCreate(
+            [message.body.key],
+            {
+              createWithInput: message.body.key
+            }
+          );
+          const result = await handle.send(
+            "work",
+            { task: "hello" },
+            {
+              wait: true,
+              timeout: 500
+            }
+          );
+          loopCtx.state.results.push({
+            key: message.body.key,
+            result,
+            error: null
+          });
+        } catch (error) {
+          loopCtx.state.results.push({
+            key: message.body.key,
+            result: null,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      });
+      await ((_a = message.complete) == null ? void 0 : _a.call(message, { ok: true }));
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    triggerSpawn: async (c, key) => {
+      await c.queue.send("spawn", { key });
+      return { queued: true };
+    },
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowAccessActor = actor({
+  db: db({
+    onMigrate: async (rawDb) => {
+      await rawDb.execute(`
+				CREATE TABLE IF NOT EXISTS workflow_access_log (
+					id INTEGER PRIMARY KEY AUTOINCREMENT,
+					created_at INTEGER NOT NULL
+				)
+			`);
+    }
+  }),
+  state: {
+    outsideDbError: null,
+    outsideClientError: null,
+    insideDbCount: 0,
+    insideClientAvailable: false
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("access", async (loopCtx) => {
+      let outsideDbError = null;
+      let outsideClientError = null;
+      try {
+        loopCtx.db;
+      } catch (error) {
+        outsideDbError = error instanceof Error ? error.message : String(error);
+      }
+      try {
+        loopCtx.client();
+      } catch (error) {
+        outsideClientError = error instanceof Error ? error.message : String(error);
+      }
+      await loopCtx.step("access-step", async () => {
+        await updateWorkflowAccessState(
+          loopCtx,
+          outsideDbError,
+          outsideClientError
+        );
+      });
+      await loopCtx.sleep("idle", 25);
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  }
+});
+var workflowSleepActor = actor({
+  state: {
+    ticks: 0
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("sleep", async (loopCtx) => {
+      await loopCtx.step("tick", async () => {
+        incrementWorkflowSleepTick(loopCtx);
+      });
+      await loopCtx.sleep("delay", 40);
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowStopTeardownActor = actor({
+  state: {
+    wakeAts: [],
+    sleepAts: []
+  },
+  queues: {
+    never: queue()
+  },
+  onWake: (c) => {
+    c.state.wakeAts.push(Date.now());
+  },
+  onSleep: (c) => {
+    c.state.sleepAts.push(Date.now());
+  },
+  run: workflow(async (ctx) => {
+    await ctx.loop("wait-forever", async (loopCtx) => {
+      await loopCtx.queue.next("wait-for-never", {
+        names: ["never"]
+      });
+      return Loop.continue(void 0);
+    });
+  }),
+  actions: {
+    getTimeline: (c) => ({
+      wakeAts: [...c.state.wakeAts],
+      sleepAts: [...c.state.sleepAts]
+    })
+  },
+  options: {
+    sleepTimeout: 75,
+    runStopTimeout: 2e3
+  }
+});
+var workflowCompleteActor = actor({
+  state: {
+    startCount: 0,
+    sleepCount: 0,
+    runCount: 0
+  },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  run: workflow(async (ctx) => {
+    await ctx.step("complete", async () => {
+      ctx.state.runCount += 1;
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowDestroyActor = actor({
+  onDestroy: async (c) => {
+    const client = c.client();
+    const observer = client.destroyObserver.getOrCreate(["observer"]);
+    await observer.notifyDestroyed(c.key.join("/"));
+  },
+  run: workflow(async (ctx) => {
+    await ctx.step("destroy", async () => {
+      ctx.destroy();
+    });
+  })
+});
+var workflowFailedStepActor = actor({
+  state: {
+    startCount: 0,
+    sleepCount: 0,
+    runCount: 0
+  },
+  onWake: (c) => {
+    c.state.startCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  run: workflow(async (ctx) => {
+    await ctx.step({
+      name: "fail",
+      maxRetries: 1,
+      run: async () => {
+        ctx.state.runCount += 1;
+        throw new Error("workflow step failed");
+      }
+    });
+  }),
+  actions: {
+    getState: (c) => c.state
+  },
+  options: {
+    sleepTimeout: 50
+  }
+});
+var workflowErrorHookActor = actor({
+  state: {
+    attempts: 0,
+    events: []
+  },
+  run: workflow(
+    async (ctx) => {
+      await ctx.step({
+        name: "flaky",
+        maxRetries: 2,
+        retryBackoffBase: 1,
+        retryBackoffMax: 1,
+        run: async () => {
+          ctx.state.attempts += 1;
+          if (ctx.state.attempts === 1) {
+            throw new Error("workflow hook failed");
+          }
+        }
+      });
+      await ctx.sleep("idle", 6e4);
+    },
+    {
+      onError: (c, event2) => {
+        c.state.events.push(event2);
+      }
+    }
+  ),
+  actions: {
+    getErrorState: (c) => c.state
+  }
+});
+var workflowErrorHookSleepActor = actor({
+  state: {
+    attempts: 0,
+    wakeCount: 0,
+    sleepCount: 0,
+    events: []
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  run: workflow(
+    async (ctx) => {
+      await ctx.step({
+        name: "flaky",
+        maxRetries: 2,
+        retryBackoffBase: 1,
+        retryBackoffMax: 1,
+        run: async () => {
+          ctx.state.attempts += 1;
+          if (ctx.state.attempts === 1) {
+            throw new Error("workflow hook failed");
+          }
+        }
+      });
+      await ctx.sleep("idle", 6e4);
+    },
+    {
+      onError: (c, event2) => {
+        c.state.events.push(event2);
+      }
+    }
+  ),
+  actions: {
+    getErrorState: (c) => c.state,
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  }
+});
+var workflowErrorHookEffectsActor = actor({
+  state: {
+    attempts: 0,
+    lastError: null,
+    errorCount: 0
+  },
+  events: {
+    workflowError: event()
+  },
+  queues: {
+    start: queue(),
+    errors: queue()
+  },
+  run: workflow(
+    async (ctx) => {
+      await ctx.queue.next("start", {
+        names: ["start"]
+      });
+      await ctx.step({
+        name: "flaky",
+        maxRetries: 2,
+        retryBackoffBase: 1,
+        retryBackoffMax: 1,
+        run: async () => {
+          ctx.state.attempts += 1;
+          if (ctx.state.attempts === 1) {
+            throw new Error("workflow hook failed");
+          }
+        }
+      });
+      await ctx.sleep("idle", 6e4);
+    },
+    {
+      onError: async (c, event2) => {
+        c.state.lastError = event2;
+        c.state.errorCount += 1;
+        c.broadcast("workflowError", event2);
+        await c.queue.send("errors", event2);
+      }
+    }
+  ),
+  actions: {
+    getErrorState: (c) => c.state,
+    startWorkflow: async (c) => {
+      const client = c.client();
+      const handle = client.workflowErrorHookEffectsActor.getForId(
+        c.actorId
+      );
+      await handle.send("start", null);
+    },
+    receiveQueuedError: async (c) => {
+      const message = await c.queue.next({
+        names: ["errors"],
+        timeout: 1e3
+      });
+      return (message == null ? void 0 : message.body) ?? null;
+    }
+  }
+});
+function incrementWorkflowCounter(ctx) {
+  ctx.state.runCount += 1;
+  ctx.state.history.push(ctx.state.runCount);
+}
+async function storeWorkflowQueueMessage(ctx, body, complete) {
+  ctx.state.received.push(body);
+  await complete({ echo: body });
+}
+async function updateWorkflowAccessState(ctx, outsideDbError, outsideClientError) {
+  var _a;
+  await ctx.db.execute(
+    `INSERT INTO workflow_access_log (created_at) VALUES (${Date.now()})`
+  );
+  const counts = await ctx.db.execute(
+    `SELECT COUNT(*) as count FROM workflow_access_log`
+  );
+  const client = ctx.client();
+  ctx.state.outsideDbError = outsideDbError;
+  ctx.state.outsideClientError = outsideClientError;
+  ctx.state.insideDbCount = ((_a = counts[0]) == null ? void 0 : _a.count) ?? 0;
+  ctx.state.insideClientAvailable = typeof client.workflowQueueActor.getForId === "function";
+}
+function incrementWorkflowSleepTick(ctx) {
+  ctx.state.ticks += 1;
+}
+
+export {
+  logger,
+  HIBERNATION_SLEEP_TIMEOUT,
+  hibernationActor,
+  SLEEP_TIMEOUT,
+  sleep,
+  sleepWithLongRpc,
+  sleepWithWaitUntilMessage,
+  sleepWithRawHttp,
+  sleepWithRawWebSocket,
+  sleepWithNoSleepOption,
+  sleepWithPreventSleep,
+  queueActor,
+  queueLimitedActor,
+  MANY_QUEUE_NAMES,
+  manyQueueChildActor,
+  manyQueueActionParentActor,
+  manyQueueRunParentActor,
+  RUN_SLEEP_TIMEOUT,
+  runWithTicks,
+  runWithQueueConsumer,
+  runWithEarlyExit,
+  runWithError,
+  runWithoutHandler,
+  WORKFLOW_QUEUE_NAME,
+  WORKFLOW_NESTED_QUEUE_NAME,
+  workflowCounterActor,
+  workflowQueueActor,
+  workflowNestedLoopActor,
+  workflowNestedJoinActor,
+  workflowNestedRaceActor,
+  workflowSpawnChildActor,
+  workflowSpawnParentActor,
+  workflowAccessActor,
+  workflowSleepActor,
+  workflowStopTeardownActor,
+  workflowCompleteActor,
+  workflowDestroyActor,
+  workflowFailedStepActor,
+  workflowErrorHookActor,
+  workflowErrorHookSleepActor,
+  workflowErrorHookEffectsActor
+};
+//# sourceMappingURL=chunk-DK46YYCJ.js.map