rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/serve-test-suite/mod.js

@@ -1,37 +1,157 @@
 import {
   hibernationActor,
   logger,
+  runWithEarlyExit,
+  runWithError,
+  runWithQueueConsumer,
+  runWithTicks,
+  runWithoutHandler,
   sleep,
   sleepWithLongRpc,
   sleepWithNoSleepOption,
   sleepWithRawHttp,
-  sleepWithRawWebSocket
-} from "../chunk-TCOEBUUE.js";
+  sleepWithRawWebSocket,
+  workflowAccessActor,
+  workflowCounterActor,
+  workflowQueueActor,
+  workflowSleepActor,
+  workflowStopTeardownActor
+} from "../chunk-OMEPCQK2.js";
+import "../chunk-7K4CYDGD.js";
+import "../chunk-IVG73YCW.js";
+import {
+  db as db2,
+  integer,
+  mod_exports,
+  sqliteTable,
+  text
+} from "../chunk-VKVNIQRQ.js";
 import {
   actor,
+  event,
+  queue,
   setup
-} from "../chunk-JDAD2YFA.js";
+} from "../chunk-5ESWDTHJ.js";
 import {
   createFileSystemOrMemoryDriver
-} from "../chunk-KCOVZOPS.js";
-import "../chunk-Q6W7RJJP.js";
-import "../chunk-XXGJCOL6.js";
+} from "../chunk-MZ37VV3P.js";
+import "../chunk-DIGBC2VI.js";
+import "../chunk-A6YIZWTK.js";
+import {
+  db
+} from "../chunk-KJSYAUOM.js";
+import "../chunk-N4KRDJ56.js";
 import {
   buildManagerRouter
-} from "../chunk-GMAVRZSF.js";
-import "../chunk-E6ZE2YEA.js";
-import "../chunk-FJ3KTN4V.js";
+} from "../chunk-M2T62AZQ.js";
+import "../chunk-LXUQ667X.js";
+import "../chunk-T5YCUGVS.js";
+import "../chunk-6LIBPELE.js";
 import {
   UserError
-} from "../chunk-LFVF5SCU.js";
+} from "../chunk-7HTNH26M.js";
+import "../chunk-424PT5DM.js";
 
 // src/serve-test-suite/mod.ts
-import { serve as honoServe } from "@hono/node-server";
-import { createNodeWebSocket } from "@hono/node-ws";
 import { createServer } from "net";
 import { fileURLToPath } from "url";
+import { serve as honoServe } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
 import invariant from "invariant";
 
+// fixtures/driver-test-suite/access-control.ts
+import { Forbidden } from "rivetkit/errors";
+var accessControlEvents = {
+  allowedEvent: event({
+    canSubscribe: (c) => {
+      c.state.lastCanSubscribeConnId = c.conn.id;
+      return true;
+    }
+  }),
+  blockedEvent: event({
+    canSubscribe: (c) => {
+      c.state.lastCanSubscribeConnId = c.conn.id;
+      return false;
+    }
+  })
+};
+var accessControlQueues = {
+  allowedQueue: queue({
+    canPublish: (c) => {
+      c.state.lastCanPublishConnId = c.conn.id;
+      return true;
+    }
+  }),
+  blockedQueue: queue({
+    canPublish: (c) => {
+      c.state.lastCanPublishConnId = c.conn.id;
+      return false;
+    }
+  })
+};
+var accessControlActor = actor({
+  state: {
+    lastCanPublishConnId: "",
+    lastCanSubscribeConnId: ""
+  },
+  events: accessControlEvents,
+  queues: accessControlQueues,
+  onBeforeConnect: (_c, params) => {
+    if ((params == null ? void 0 : params.allowRequest) === false || (params == null ? void 0 : params.allowWebSocket) === false) {
+      throw new Forbidden();
+    }
+  },
+  onRequest(_c, request) {
+    const url = new URL(request.url);
+    if (url.pathname === "/status") {
+      return Response.json({ ok: true });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  onWebSocket(_c, websocket) {
+    websocket.send(JSON.stringify({ type: "welcome" }));
+  },
+  actions: {
+    allowedAction: (_c, value) => {
+      return `allowed:${value}`;
+    },
+    allowedGetLastCanPublishConnId: (c) => {
+      return c.state.lastCanPublishConnId;
+    },
+    allowedGetLastCanSubscribeConnId: (c) => {
+      return c.state.lastCanSubscribeConnId;
+    },
+    allowedReceiveQueue: async (c) => {
+      const [message] = await c.queue.tryNext({
+        names: ["allowedQueue"]
+      });
+      return (message == null ? void 0 : message.body) ?? null;
+    },
+    allowedReceiveAnyQueue: async (c) => {
+      const [message] = await c.queue.tryNext();
+      return (message == null ? void 0 : message.body) ?? null;
+    },
+    allowedBroadcastAllowedEvent: (c, value) => {
+      c.broadcast("allowedEvent", { value });
+    },
+    allowedBroadcastBlockedEvent: (c, value) => {
+      c.broadcast("blockedEvent", { value });
+    },
+    allowedBroadcastUndefinedEvent: (c, value) => {
+      c.broadcast("undefinedEvent", { value });
+    }
+  }
+});
+var accessControlNoQueuesActor = actor({
+  state: {},
+  actions: {
+    readAnyQueue: async (c) => {
+      const [message] = await c.queue.tryNext();
+      return (message == null ? void 0 : message.body) ?? null;
+    }
+  }
+});
+
 // fixtures/driver-test-suite/action-inputs.ts
 var inputActor = actor({
   createState: (c, input) => {
@@ -178,6 +298,680 @@ var promiseActor = actor({
   }
 });
 
+// fixtures/driver-test-suite/actor-db-raw.ts
+function firstRowValue(row) {
+  if (!row) {
+    return void 0;
+  }
+  const values = Object.values(row);
+  return values.length > 0 ? values[0] : void 0;
+}
+function toSafeInteger(value) {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? Math.trunc(value) : 0;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function normalizeRowIds(rowIds) {
+  const normalized = rowIds.map((id) => Math.trunc(id)).filter((id) => Number.isFinite(id) && id > 0);
+  return Array.from(new Set(normalized));
+}
+function makePayload(size) {
+  const normalizedSize = Math.max(0, Math.trunc(size));
+  return "x".repeat(normalizedSize);
+}
+var dbActorRaw = actor({
+  state: {
+    disconnectInsertEnabled: false,
+    disconnectInsertDelayMs: 0
+  },
+  db: db({
+    onMigrate: async (db3) => {
+      await db3.execute(`
+				CREATE TABLE IF NOT EXISTS test_data (
+					id INTEGER PRIMARY KEY AUTOINCREMENT,
+					value TEXT NOT NULL,
+					payload TEXT NOT NULL DEFAULT '',
+					created_at INTEGER NOT NULL
+				)
+			`);
+    }
+  }),
+  onDisconnect: async (c) => {
+    if (!c.state.disconnectInsertEnabled) {
+      return;
+    }
+    if (c.state.disconnectInsertDelayMs > 0) {
+      await new Promise(
+        (resolve) => setTimeout(resolve, c.state.disconnectInsertDelayMs)
+      );
+    }
+    await c.db.execute(
+      `INSERT INTO test_data (value, payload, created_at) VALUES ('__disconnect__', '', ${Date.now()})`
+    );
+  },
+  actions: {
+    configureDisconnectInsert: (c, enabled, delayMs) => {
+      c.state.disconnectInsertEnabled = enabled;
+      c.state.disconnectInsertDelayMs = Math.max(
+        0,
+        Math.floor(delayMs)
+      );
+    },
+    getDisconnectInsertCount: async (c) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data WHERE value = '__disconnect__'`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    reset: async (c) => {
+      await c.db.execute(`DELETE FROM test_data`);
+    },
+    insertValue: async (c, value) => {
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()})`
+      );
+      const results = await c.db.execute(
+        `SELECT last_insert_rowid() as id`
+      );
+      return { id: results[0].id };
+    },
+    getValues: async (c) => {
+      const results = await c.db.execute(
+        `SELECT * FROM test_data ORDER BY id`
+      );
+      return results;
+    },
+    getValue: async (c, id) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT value FROM test_data WHERE id = ${id}`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.value) ?? null;
+    },
+    getCount: async (c) => {
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data`
+      );
+      return results[0].count;
+    },
+    rawSelectCount: async (c) => {
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data`
+      );
+      return results[0].count;
+    },
+    insertMany: async (c, count) => {
+      if (count <= 0) {
+        return { count: 0 };
+      }
+      const now = Date.now();
+      const values = [];
+      for (let i = 0; i < count; i++) {
+        values.push(`('User ${i}', '', ${now})`);
+      }
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ${values.join(", ")}`
+      );
+      return { count };
+    },
+    updateValue: async (c, id, value) => {
+      await c.db.execute(
+        `UPDATE test_data SET value = '${value}' WHERE id = ${id}`
+      );
+      return { success: true };
+    },
+    deleteValue: async (c, id) => {
+      await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+    },
+    transactionCommit: async (c, value) => {
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); COMMIT;`
+      );
+    },
+    transactionRollback: async (c, value) => {
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); ROLLBACK;`
+      );
+    },
+    insertPayloadOfSize: async (c, size) => {
+      const payload = "x".repeat(size);
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ('payload', '${payload}', ${Date.now()})`
+      );
+      const results = await c.db.execute(
+        `SELECT last_insert_rowid() as id`
+      );
+      return { id: results[0].id, size };
+    },
+    getPayloadSize: async (c, id) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT length(payload) as size FROM test_data WHERE id = ${id}`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.size) ?? 0;
+    },
+    insertPayloadRows: async (c, count, payloadSize) => {
+      const normalizedCount = Math.max(0, Math.trunc(count));
+      if (normalizedCount === 0) {
+        return { count: 0 };
+      }
+      const payload = makePayload(payloadSize);
+      const now = Date.now();
+      for (let i = 0; i < normalizedCount; i++) {
+        await c.db.execute(
+          `INSERT INTO test_data (value, payload, created_at) VALUES ('bulk-${i}', '${payload}', ${now})`
+        );
+      }
+      return { count: normalizedCount };
+    },
+    roundRobinUpdateValues: async (c, rowIds, iterations) => {
+      const normalizedRowIds = normalizeRowIds(rowIds);
+      const normalizedIterations = Math.max(0, Math.trunc(iterations));
+      if (normalizedRowIds.length === 0 || normalizedIterations === 0) {
+        const emptyRows = [];
+        return emptyRows;
+      }
+      for (let i = 0; i < normalizedIterations; i++) {
+        const rowId = normalizedRowIds[i % normalizedRowIds.length] ?? 0;
+        await c.db.execute(
+          `UPDATE test_data SET value = 'v-${i}' WHERE id = ${rowId}`
+        );
+      }
+      return await c.db.execute(
+        `SELECT id, value FROM test_data WHERE id IN (${normalizedRowIds.join(",")}) ORDER BY id`
+      );
+    },
+    getPageCount: async (c) => {
+      const rows = await c.db.execute(
+        "PRAGMA page_count"
+      );
+      return toSafeInteger(firstRowValue(rows[0]));
+    },
+    vacuum: async (c) => {
+      await c.db.execute("VACUUM");
+    },
+    integrityCheck: async (c) => {
+      const rows = await c.db.execute(
+        "PRAGMA integrity_check"
+      );
+      const value = firstRowValue(rows[0]);
+      return String(value ?? "");
+    },
+    runMixedWorkload: async (c, seedCount, churnCount) => {
+      const normalizedSeedCount = Math.max(1, Math.trunc(seedCount));
+      const normalizedChurnCount = Math.max(0, Math.trunc(churnCount));
+      const now = Date.now();
+      for (let i = 0; i < normalizedSeedCount; i++) {
+        const payload = makePayload(1024 + i % 5 * 128);
+        await c.db.execute(
+          `INSERT OR REPLACE INTO test_data (id, value, payload, created_at) VALUES (${i + 1}, 'seed-${i}', '${payload}', ${now})`
+        );
+      }
+      for (let i = 0; i < normalizedChurnCount; i++) {
+        const id = i % normalizedSeedCount + 1;
+        if (i % 9 === 0) {
+          await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+        } else {
+          const payload = makePayload(768 + i % 7 * 96);
+          await c.db.execute(
+            `INSERT OR REPLACE INTO test_data (id, value, payload, created_at) VALUES (${id}, 'upd-${i}', '${payload}', ${now + i})`
+          );
+        }
+      }
+    },
+    repeatUpdate: async (c, id, count) => {
+      let value = "";
+      if (count <= 0) {
+        return { value };
+      }
+      const statements = ["BEGIN"];
+      for (let i = 0; i < count; i++) {
+        value = `Updated ${i}`;
+        statements.push(
+          `UPDATE test_data SET value = '${value}' WHERE id = ${id}`
+        );
+      }
+      statements.push("COMMIT");
+      await c.db.execute(statements.join("; "));
+      return { value };
+    },
+    multiStatementInsert: async (c, value) => {
+      var _a;
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); UPDATE test_data SET value = '${value}-updated' WHERE id = last_insert_rowid(); COMMIT;`
+      );
+      const results = await c.db.execute(
+        `SELECT value FROM test_data ORDER BY id DESC LIMIT 1`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.value) ?? null;
+    },
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: 100
+  }
+});
+
+// fixtures/driver-test-suite/db/migrations.ts
+var migrations = {
+  journal: {
+    entries: [
+      {
+        idx: 0,
+        when: 17e11,
+        tag: "0000_init",
+        breakpoints: false
+      }
+    ]
+  },
+  migrations: {
+    m0000: `
+			CREATE TABLE IF NOT EXISTS test_data (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				value TEXT NOT NULL,
+				payload TEXT NOT NULL DEFAULT '',
+				created_at INTEGER NOT NULL
+			);
+		`
+  }
+};
+
+// fixtures/driver-test-suite/db/schema.ts
+var testData = sqliteTable("test_data", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  value: text("value").notNull(),
+  payload: text("payload").notNull().default(""),
+  createdAt: integer("created_at").notNull()
+});
+var schema = {
+  testData
+};
+
+// fixtures/driver-test-suite/actor-db-drizzle.ts
+function firstRowValue2(row) {
+  if (!row) {
+    return void 0;
+  }
+  const values = Object.values(row);
+  return values.length > 0 ? values[0] : void 0;
+}
+function toSafeInteger2(value) {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? Math.trunc(value) : 0;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function normalizeRowIds2(rowIds) {
+  const normalized = rowIds.map((id) => Math.trunc(id)).filter((id) => Number.isFinite(id) && id > 0);
+  return Array.from(new Set(normalized));
+}
+function makePayload2(size) {
+  const normalizedSize = Math.max(0, Math.trunc(size));
+  return "x".repeat(normalizedSize);
+}
+var dbActorDrizzle = actor({
+  state: {
+    disconnectInsertEnabled: false,
+    disconnectInsertDelayMs: 0
+  },
+  db: db2({
+    schema,
+    migrations
+  }),
+  onDisconnect: async (c) => {
+    if (!c.state.disconnectInsertEnabled) {
+      return;
+    }
+    if (c.state.disconnectInsertDelayMs > 0) {
+      await new Promise(
+        (resolve) => setTimeout(resolve, c.state.disconnectInsertDelayMs)
+      );
+    }
+    await c.db.execute(
+      `INSERT INTO test_data (value, payload, created_at) VALUES ('__disconnect__', '', ${Date.now()})`
+    );
+  },
+  actions: {
+    configureDisconnectInsert: (c, enabled, delayMs) => {
+      c.state.disconnectInsertEnabled = enabled;
+      c.state.disconnectInsertDelayMs = Math.max(
+        0,
+        Math.floor(delayMs)
+      );
+    },
+    getDisconnectInsertCount: async (c) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data WHERE value = '__disconnect__'`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    reset: async (c) => {
+      await c.db.execute(`DELETE FROM test_data`);
+    },
+    insertValue: async (c, value) => {
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()})`
+      );
+      const results = await c.db.execute(
+        `SELECT last_insert_rowid() as id`
+      );
+      return { id: results[0].id };
+    },
+    getValues: async (c) => {
+      const results = await c.db.execute(
+        `SELECT * FROM test_data ORDER BY id`
+      );
+      return results;
+    },
+    getValue: async (c, id) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT value FROM test_data WHERE id = ${id}`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.value) ?? null;
+    },
+    getCount: async (c) => {
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data`
+      );
+      return results[0].count;
+    },
+    rawSelectCount: async (c) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM test_data`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    insertMany: async (c, count) => {
+      if (count <= 0) {
+        return { count: 0 };
+      }
+      const now = Date.now();
+      const values = [];
+      for (let i = 0; i < count; i++) {
+        values.push(`('User ${i}', '', ${now})`);
+      }
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ${values.join(", ")}`
+      );
+      return { count };
+    },
+    updateValue: async (c, id, value) => {
+      await c.db.execute(
+        `UPDATE test_data SET value = '${value}' WHERE id = ${id}`
+      );
+      return { success: true };
+    },
+    deleteValue: async (c, id) => {
+      await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+    },
+    transactionCommit: async (c, value) => {
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); COMMIT;`
+      );
+    },
+    transactionRollback: async (c, value) => {
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); ROLLBACK;`
+      );
+    },
+    insertPayloadOfSize: async (c, size) => {
+      const payload = "x".repeat(size);
+      await c.db.execute(
+        `INSERT INTO test_data (value, payload, created_at) VALUES ('payload', '${payload}', ${Date.now()})`
+      );
+      const results = await c.db.execute(
+        `SELECT last_insert_rowid() as id`
+      );
+      return { id: results[0].id, size };
+    },
+    getPayloadSize: async (c, id) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT length(payload) as size FROM test_data WHERE id = ${id}`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.size) ?? 0;
+    },
+    insertPayloadRows: async (c, count, payloadSize) => {
+      const normalizedCount = Math.max(0, Math.trunc(count));
+      if (normalizedCount === 0) {
+        return { count: 0 };
+      }
+      const payload = makePayload2(payloadSize);
+      const now = Date.now();
+      for (let i = 0; i < normalizedCount; i++) {
+        await c.db.execute(
+          `INSERT INTO test_data (value, payload, created_at) VALUES ('bulk-${i}', '${payload}', ${now})`
+        );
+      }
+      return { count: normalizedCount };
+    },
+    roundRobinUpdateValues: async (c, rowIds, iterations) => {
+      const normalizedRowIds = normalizeRowIds2(rowIds);
+      const normalizedIterations = Math.max(0, Math.trunc(iterations));
+      if (normalizedRowIds.length === 0 || normalizedIterations === 0) {
+        const emptyRows = [];
+        return emptyRows;
+      }
+      for (let i = 0; i < normalizedIterations; i++) {
+        const rowId = normalizedRowIds[i % normalizedRowIds.length] ?? 0;
+        await c.db.execute(
+          `UPDATE test_data SET value = 'v-${i}' WHERE id = ${rowId}`
+        );
+      }
+      return await c.db.execute(
+        `SELECT id, value FROM test_data WHERE id IN (${normalizedRowIds.join(",")}) ORDER BY id`
+      );
+    },
+    getPageCount: async (c) => {
+      const rows = await c.db.execute(
+        "PRAGMA page_count"
+      );
+      return toSafeInteger2(firstRowValue2(rows[0]));
+    },
+    vacuum: async (c) => {
+      await c.db.execute("VACUUM");
+    },
+    integrityCheck: async (c) => {
+      const rows = await c.db.execute(
+        "PRAGMA integrity_check"
+      );
+      const value = firstRowValue2(rows[0]);
+      return String(value ?? "");
+    },
+    runMixedWorkload: async (c, seedCount, churnCount) => {
+      const normalizedSeedCount = Math.max(1, Math.trunc(seedCount));
+      const normalizedChurnCount = Math.max(0, Math.trunc(churnCount));
+      const now = Date.now();
+      for (let i = 0; i < normalizedSeedCount; i++) {
+        const payload = makePayload2(1024 + i % 5 * 128);
+        await c.db.execute(
+          `INSERT OR REPLACE INTO test_data (id, value, payload, created_at) VALUES (${i + 1}, 'seed-${i}', '${payload}', ${now})`
+        );
+      }
+      for (let i = 0; i < normalizedChurnCount; i++) {
+        const id = i % normalizedSeedCount + 1;
+        if (i % 9 === 0) {
+          await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+        } else {
+          const payload = makePayload2(768 + i % 7 * 96);
+          await c.db.execute(
+            `INSERT OR REPLACE INTO test_data (id, value, payload, created_at) VALUES (${id}, 'upd-${i}', '${payload}', ${now + i})`
+          );
+        }
+      }
+    },
+    repeatUpdate: async (c, id, count) => {
+      let value = "";
+      if (count <= 0) {
+        return { value };
+      }
+      const statements = ["BEGIN"];
+      for (let i = 0; i < count; i++) {
+        value = `Updated ${i}`;
+        statements.push(
+          `UPDATE test_data SET value = '${value}' WHERE id = ${id}`
+        );
+      }
+      statements.push("COMMIT");
+      await c.db.execute(statements.join("; "));
+      return { value };
+    },
+    multiStatementInsert: async (c, value) => {
+      var _a;
+      await c.db.execute(
+        `BEGIN; INSERT INTO test_data (value, payload, created_at) VALUES ('${value}', '', ${Date.now()}); UPDATE test_data SET value = '${value}-updated' WHERE id = last_insert_rowid(); COMMIT;`
+      );
+      const results = await c.db.execute(
+        `SELECT value FROM test_data ORDER BY id DESC LIMIT 1`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.value) ?? null;
+    },
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: 100
+  }
+});
+
+// fixtures/driver-test-suite/db-lifecycle.ts
+var clientActorIds = /* @__PURE__ */ new WeakMap();
+var createCounts = /* @__PURE__ */ new Map();
+var migrateCounts = /* @__PURE__ */ new Map();
+var cleanupCounts = /* @__PURE__ */ new Map();
+function increment(map, actorId) {
+  map.set(actorId, (map.get(actorId) ?? 0) + 1);
+}
+function getCounts(actorId) {
+  return {
+    create: createCounts.get(actorId) ?? 0,
+    migrate: migrateCounts.get(actorId) ?? 0,
+    cleanup: cleanupCounts.get(actorId) ?? 0
+  };
+}
+var baseProvider = db({
+  onMigrate: async (dbHandle) => {
+    await dbHandle.execute(`
+			CREATE TABLE IF NOT EXISTS lifecycle_data (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				value TEXT NOT NULL,
+				created_at INTEGER NOT NULL
+			)
+		`);
+  }
+});
+var lifecycleProvider = {
+  createClient: async (ctx) => {
+    const client = await baseProvider.createClient(ctx);
+    clientActorIds.set(client, ctx.actorId);
+    increment(createCounts, ctx.actorId);
+    return client;
+  },
+  onMigrate: async (client) => {
+    const actorId = clientActorIds.get(client);
+    if (actorId) {
+      increment(migrateCounts, actorId);
+    }
+    await baseProvider.onMigrate(client);
+  },
+  onDestroy: async (client) => {
+    var _a;
+    const actorId = clientActorIds.get(client);
+    if (actorId) {
+      increment(cleanupCounts, actorId);
+    }
+    await ((_a = baseProvider.onDestroy) == null ? void 0 : _a.call(baseProvider, client));
+  }
+};
+var failingLifecycleProvider = {
+  createClient: async (ctx) => {
+    const client = await baseProvider.createClient(ctx);
+    clientActorIds.set(client, ctx.actorId);
+    increment(createCounts, ctx.actorId);
+    return client;
+  },
+  onMigrate: async (client) => {
+    const actorId = clientActorIds.get(client);
+    if (actorId) {
+      increment(migrateCounts, actorId);
+    }
+    throw new Error("forced migrate failure");
+  },
+  onDestroy: async (client) => {
+    var _a;
+    const actorId = clientActorIds.get(client);
+    if (actorId) {
+      increment(cleanupCounts, actorId);
+    }
+    await ((_a = baseProvider.onDestroy) == null ? void 0 : _a.call(baseProvider, client));
+  }
+};
+var dbLifecycle = actor({
+  db: lifecycleProvider,
+  actions: {
+    getActorId: (c) => c.actorId,
+    ping: () => "pong",
+    insertValue: async (c, value) => {
+      await c.db.execute(
+        "INSERT INTO lifecycle_data (value, created_at) VALUES (?, ?)",
+        value,
+        Date.now()
+      );
+    },
+    getCount: async (c) => {
+      var _a;
+      const results = await c.db.execute(
+        `SELECT COUNT(*) as count FROM lifecycle_data`
+      );
+      return ((_a = results[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    triggerDestroy: (c) => {
+      c.destroy();
+    }
+  },
+  options: {
+    sleepTimeout: 100
+  }
+});
+var dbLifecycleFailing = actor({
+  db: failingLifecycleProvider,
+  actions: {
+    ping: () => "pong"
+  }
+});
+var dbLifecycleObserver = actor({
+  actions: {
+    getCounts: (_c, actorId) => {
+      return getCounts(actorId);
+    }
+  }
+});
+
 // fixtures/driver-test-suite/actor-onstatechange.ts
 var onStateChangeActor = actor({
   state: {
@@ -348,6 +1142,9 @@ var counter = actor({
     },
     getCount: (c) => {
       return c.state.count;
+    },
+    getKey: (c) => {
+      return c.key;
     }
   }
 });
@@ -504,6 +1301,41 @@ var customTimeoutActor = actor({
   }
 });
 
+// fixtures/driver-test-suite/file-system-hibernation-cleanup.ts
+var fileSystemHibernationCleanupActor = actor({
+  state: {
+    wakeCount: 0,
+    sleepCount: 0,
+    disconnectWakeCounts: []
+  },
+  createConnState: () => ({}),
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onDisconnect: (c, conn) => {
+    if (conn.isHibernatable) {
+      c.state.disconnectWakeCounts.push(c.state.wakeCount);
+    }
+  },
+  actions: {
+    ping: () => "pong",
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    getCounts: (c) => ({
+      wakeCount: c.state.wakeCount,
+      sleepCount: c.state.sleepCount
+    }),
+    getDisconnectWakeCounts: (c) => c.state.disconnectWakeCounts
+  },
+  options: {
+    sleepTimeout: 500
+  }
+});
+
 // fixtures/driver-test-suite/inline-client.ts
 var inlineClientActor = actor({
   state: { messages: [] },
@@ -750,6 +1582,201 @@ var metadataActor = actor({
   }
 });
 
+// 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 messages = await c.queue.next({
+        names: [name],
+        count: opts == null ? void 0 : opts.count,
+        timeout: opts == null ? void 0 : opts.timeout
+      });
+      const message = messages[0];
+      if (!message) {
+        return null;
+      }
+      return { name: message.name, body: message.body };
+    },
+    receiveMany: async (c, names, opts) => {
+      const messages = await c.queue.next({
+        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.next(request);
+      return messages.map((message) => ({
+        name: message.name,
+        body: message.body
+      }));
+    },
+    tryReceiveMany: async (c, request) => {
+      const messages = await c.queue.tryNext(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 messages = await c.queue.next({ names: [name], completable: true });
+      const message = messages[0];
+      if (!message) {
+        return null;
+      }
+      await message.complete({ echo: message.body });
+      return { name: message.name, body: message.body };
+    },
+    receiveWithoutComplete: async (c, name) => {
+      const messages = await c.queue.next({ names: [name], completable: true });
+      const message = messages[0];
+      if (!message) {
+        return null;
+      }
+      return { name: message.name, body: message.body };
+    },
+    receiveManualThenNextWithoutComplete: async (c, name) => {
+      const messages = await c.queue.next({ names: [name], completable: true });
+      const message = messages[0];
+      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 messages = await c.queue.next({ names: [name], completable: true });
+      const message = messages[0];
+      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 messages = await c.queue.next({ names: [name], completable: true });
+      const message = messages[0];
+      return {
+        hasComplete: message !== void 0 && typeof message.complete === "function"
+      };
+    }
+  }
+});
+var queueLimitedActor = actor({
+  state: {},
+  queues: {
+    message: queue(),
+    oversize: queue()
+  },
+  actions: {},
+  options: {
+    maxQueueSize: 1,
+    maxQueueMessageSize: 64
+  }
+});
+
 // fixtures/driver-test-suite/raw-http.ts
 import { Hono } from "hono";
 var rawHttpActor = actor({
@@ -864,11 +1891,11 @@ var rawHttpRequestPropertiesActor = actor({
       const contentType = request.headers.get("content-type") || "";
       try {
         if (contentType.includes("application/json")) {
-          const text = await request.text();
-          return text ? JSON.parse(text) : null;
+          const text2 = await request.text();
+          return text2 ? JSON.parse(text2) : null;
         } else {
-          const text = await request.text();
-          return text || null;
+          const text2 = await request.text();
+          return text2 || null;
         }
       } catch (error) {
         return null;
@@ -933,14 +1960,14 @@ var rawWebSocketActor = actor({
       })
     );
     console.log("[ACTOR] Sent welcome message");
-    websocket.addEventListener("message", (event) => {
+    websocket.addEventListener("message", (event2) => {
       var _a;
       ctx.state.messageCount = ctx.state.messageCount + 1;
       console.log(
         `[ACTOR] Message received, total count: ${ctx.state.messageCount}, data:`,
-        event.data
+        event2.data
       );
-      const data = event.data;
+      const data = event2.data;
       if (typeof data === "string") {
         try {
           const parsed = JSON.parse(data);
@@ -1001,8 +2028,8 @@ var rawWebSocketActor = actor({
 });
 var rawWebSocketBinaryActor = actor({
   onWebSocket(ctx, websocket) {
-    websocket.addEventListener("message", (event) => {
-      const data = event.data;
+    websocket.addEventListener("message", (event2) => {
+      const data = event2.data;
       if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
         const bytes = new Uint8Array(data);
         const reversed = new Uint8Array(bytes.length);
@@ -1125,8 +2152,8 @@ var requestAccessActor = actor({
         requestHeaders: headers
       })
     );
-    websocket.addEventListener("message", (event) => {
-      websocket.send(event.data);
+    websocket.addEventListener("message", (event2) => {
+      websocket.send(event2.data);
     });
   },
   actions: {
@@ -1223,6 +2250,33 @@ var scheduled = actor({
   }
 });
 
+// fixtures/driver-test-suite/stateless.ts
+var statelessActor = actor({
+  actions: {
+    ping: () => "pong",
+    echo: (c, message) => message,
+    getActorId: (c) => c.actorId,
+    // Try to access state - should throw StateNotEnabled
+    tryGetState: (c) => {
+      try {
+        const state = c.state;
+        return { success: true, state };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    },
+    // Try to access db - should throw DatabaseNotEnabled
+    tryGetDb: (c) => {
+      try {
+        const db3 = c.db;
+        return { success: true, db: db3 };
+      } catch (error) {
+        return { success: false, error: error.message };
+      }
+    }
+  }
+});
+
 // fixtures/driver-test-suite/vars.ts
 var staticVarActor = actor({
   state: { value: 0 },
@@ -1328,6 +2382,9 @@ var registry = setup({
     inlineClientActor,
     // From kv.ts
     kvActor,
+    // From queue.ts
+    queueActor,
+    queueLimitedActor,
     // From action-inputs.ts
     inputActor,
     // From action-timeout.ts
@@ -1372,9 +2429,36 @@ var registry = setup({
     destroyObserver,
     // From hibernation.ts
     hibernationActor,
+    // From file-system-hibernation-cleanup.ts
+    fileSystemHibernationCleanupActor,
     // From large-payloads.ts
     largePayloadActor,
-    largePayloadConnActor
+    largePayloadConnActor,
+    // From run.ts
+    runWithTicks,
+    runWithQueueConsumer,
+    runWithEarlyExit,
+    runWithError,
+    runWithoutHandler,
+    // From workflow.ts
+    workflowCounterActor,
+    workflowQueueActor,
+    workflowAccessActor,
+    workflowSleepActor,
+    workflowStopTeardownActor,
+    // From actor-db-raw.ts
+    dbActorRaw,
+    // From actor-db-drizzle.ts
+    dbActorDrizzle,
+    // From db-lifecycle.ts
+    dbLifecycle,
+    dbLifecycleFailing,
+    dbLifecycleObserver,
+    // From stateless.ts
+    statelessActor,
+    // From access-control.ts
+    accessControlActor,
+    accessControlNoQueuesActor
   }
 });
 
@@ -1428,10 +2512,9 @@ async function serveTestSuite() {
     ...registry.config.serverless,
     publicEndpoint: `http://127.0.0.1:${port}`
   };
-  const driver = await createFileSystemOrMemoryDriver(
-    true,
-    `/tmp/rivetkit-test-suite-${crypto.randomUUID()}`
-  );
+  const driver = await createFileSystemOrMemoryDriver(true, {
+    path: `/tmp/rivetkit-test-suite-${crypto.randomUUID()}`
+  });
   registry.config.driver = driver;
   let upgradeWebSocket;
   const parsedConfig = registry.parseConfig();
@@ -1462,7 +2545,9 @@ async function serveTestSuite() {
     namespace: "default",
     runnerName: "default",
     close: async () => {
-      await new Promise((resolve) => server.close(() => resolve(void 0)));
+      await new Promise(
+        (resolve) => server.close(() => resolve(void 0))
+      );
     }
   };
 }