rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/driver-test-suite/mod.cjs

@@ -2,21 +2,24 @@
 
 
 
-var _chunk2IJTYN6Kcjs = require('../chunk-2IJTYN6K.cjs');
 
 
-var _chunk3VP5CSHVcjs = require('../chunk-3VP5CSHV.cjs');
-require('../chunk-X35U3YNX.cjs');
-require('../chunk-RUW5CZ5Z.cjs');
+var _chunkXWBAQO5Hcjs = require('../chunk-XWBAQO5H.cjs');
+require('../chunk-AIYEYMX5.cjs');
+require('../chunk-HAZL2EPK.cjs');
+require('../chunk-TYLXNCA5.cjs');
+require('../chunk-YQ4LDVD6.cjs');
 
 
 
 
 
-var _chunkGD7UXGOEcjs = require('../chunk-GD7UXGOE.cjs');
+var _chunkSSEP6DHPcjs = require('../chunk-SSEP6DHP.cjs');
 
 
-var _chunkEJVBH5VFcjs = require('../chunk-EJVBH5VF.cjs');
+var _chunkTPGXWFQTcjs = require('../chunk-TPGXWFQT.cjs');
+require('../chunk-6LJAZ5R4.cjs');
+require('../chunk-SR3KQE7Q.cjs');
 
 
 
@@ -26,17 +29,19 @@ var _chunkEJVBH5VFcjs = require('../chunk-EJVBH5VF.cjs');
 
 
 
+var _chunkF6JYU5IKcjs = require('../chunk-F6JYU5IK.cjs');
+require('../chunk-NIYZDWMW.cjs');
 
-var _chunkRZW2DNNDcjs = require('../chunk-RZW2DNND.cjs');
-require('../chunk-KDFWJKMJ.cjs');
 
+var _chunkHIDX4C5Ycjs = require('../chunk-HIDX4C5Y.cjs');
 
-var _chunkH4TB4X25cjs = require('../chunk-H4TB4X25.cjs');
 
+var _chunkLW6KLR7Acjs = require('../chunk-LW6KLR7A.cjs');
 
 
-var _chunk2XQS746Mcjs = require('../chunk-2XQS746M.cjs');
-require('../chunk-GBENOENJ.cjs');
+
+var _chunkL47L3ZWJcjs = require('../chunk-L47L3ZWJ.cjs');
+require('../chunk-HDQ2JUQT.cjs');
 
 // src/driver-test-suite/mod.ts
 var _nodeserver = require('@hono/node-server');
@@ -80,20 +85,20 @@ function createTestInlineClientDriver(endpoint, encoding) {
       const oldUrl = new URL(actorRequest.url);
       const normalizedPath = oldUrl.pathname.startsWith("/") ? oldUrl.pathname.slice(1) : oldUrl.pathname;
       const pathWithQuery = normalizedPath + oldUrl.search;
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkXWBAQO5Hcjs.logger.call(void 0, ).debug({
         msg: "sending raw http request via test inline driver",
         actorId,
         encoding,
         path: pathWithQuery
       });
       const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkXWBAQO5Hcjs.logger.call(void 0, ).debug({
         msg: "rewriting http url",
         from: oldUrl,
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkRZW2DNNDcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkF6JYU5IKcjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -109,7 +114,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkGD7UXGOEcjs.ActorError)(
+              throw new (0, _chunkSSEP6DHPcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -117,7 +122,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkGD7UXGOEcjs.ActorError)) {
+          if (!(e instanceof _chunkSSEP6DHPcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -126,33 +131,33 @@ function createTestInlineClientDriver(endpoint, encoding) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkEJVBH5VFcjs.importWebSocket.call(void 0, );
+      const WebSocket2 = await _chunkTPGXWFQTcjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkXWBAQO5Hcjs.logger.call(void 0, ).debug({
         msg: "creating websocket connection via test inline driver",
         url: wsUrl.toString()
       });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       const protocols = [];
-      protocols.push(_chunkRZW2DNNDcjs.WS_PROTOCOL_STANDARD);
-      protocols.push(`${_chunkRZW2DNNDcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(_chunkF6JYU5IKcjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunkF6JYU5IKcjs.WS_PROTOCOL_TARGET}actor`);
       protocols.push(
-        `${_chunkRZW2DNNDcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+        `${_chunkF6JYU5IKcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
       );
-      protocols.push(`${_chunkRZW2DNNDcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkF6JYU5IKcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunkRZW2DNNDcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunkF6JYU5IKcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunkRZW2DNNDcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunkF6JYU5IKcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkXWBAQO5Hcjs.logger.call(void 0, ).debug({
         msg: "connecting to websocket",
         url: finalWsUrl,
         protocols
@@ -172,7 +177,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
         encoding2,
         params
       );
-      return upgradeWebSocket(() => wsHandler)(c, _chunkH4TB4X25cjs.noopNext.call(void 0, ));
+      return upgradeWebSocket(() => wsHandler)(c, _chunkLW6KLR7Acjs.noopNext.call(void 0, ));
     },
     async buildGatewayUrl(actorId) {
       return `${endpoint}/gateway/${actorId}`;
@@ -189,7 +194,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
   };
 }
 async function makeInlineRequest(endpoint, encoding, method, args) {
-  _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+  _chunkXWBAQO5Hcjs.logger.call(void 0, ).debug({
     msg: "sending inline request",
     encoding,
     method,
@@ -219,14 +224,14 @@ async function makeInlineRequest(endpoint, encoding, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkGD7UXGOEcjs.ActorError)(
+    throw new (0, _chunkSSEP6DHPcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkHIDX4C5Ycjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -239,12 +244,12 @@ async function setupDriverTest(c, driverTestConfig) {
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   c.onTestFinished(() => {
-    _chunk2IJTYN6Kcjs.logger.call(void 0, ).info("cleaning up test");
+    _chunkXWBAQO5Hcjs.logger.call(void 0, ).info("cleaning up test");
     cleanup();
   });
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkGD7UXGOEcjs.createClient.call(void 0, {
+    client = _chunkSSEP6DHPcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -257,12 +262,12 @@ async function setupDriverTest(c, driverTestConfig) {
   } else if (driverTestConfig.clientType === "inline") {
     const encoding = _nullishCoalesce(driverTestConfig.encoding, () => ( "bare"));
     const managerDriver = createTestInlineClientDriver(endpoint, encoding);
-    const runConfig = _chunkGD7UXGOEcjs.ClientConfigSchema.parse({
+    const runConfig = _chunkSSEP6DHPcjs.ClientConfigSchema.parse({
       encoding
     });
-    client = _chunkGD7UXGOEcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkSSEP6DHPcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkHIDX4C5Ycjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -404,6 +409,194 @@ function runActionFeaturesTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/access-control.ts
+
+function runAccessControlTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "access control", () => {
+    _vitest.test.call(void 0, "actions run without entrypoint auth gating", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlActor.getOrCreate(["actions"]);
+      const allowed = await handle.allowedAction("ok");
+      _vitest.expect.call(void 0, allowed).toBe("allowed:ok");
+    });
+    _vitest.test.call(void 0, "passes connection id into canPublish context", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlActor.getOrCreate(["publish-ctx"]);
+      await handle.send("allowedQueue", { value: "one" });
+      const connId = await handle.allowedGetLastCanPublishConnId();
+      _vitest.expect.call(void 0, typeof connId).toBe("string");
+      _vitest.expect.call(void 0, connId.length).toBeGreaterThan(0);
+    });
+    _vitest.test.call(void 0, "allows and denies queue sends, and ignores undefined queues", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlActor.getOrCreate(["queue"]);
+      await handle.send("allowedQueue", { value: "one" });
+      await _vitest.expect.call(void 0, 
+        handle.send("blockedQueue", { value: "two" })
+      ).rejects.toMatchObject({
+        code: "forbidden"
+      });
+      await _vitest.expect.call(void 0, 
+        handle.send("missingQueue", { value: "three" })
+      ).resolves.toBeUndefined();
+      await _vitest.expect.call(void 0, 
+        handle.send(
+          "missingQueue",
+          { value: "four" },
+          { wait: true, timeout: 50 }
+        )
+      ).resolves.toMatchObject({ status: "completed" });
+      const allowedMessage = await handle.allowedReceiveQueue();
+      _vitest.expect.call(void 0, allowedMessage).toEqual({ value: "one" });
+      const remainingMessage = await handle.allowedReceiveAnyQueue();
+      _vitest.expect.call(void 0, remainingMessage).toBeNull();
+    });
+    _vitest.test.call(void 0, "ignores incoming queue sends when actor has no queues config", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlNoQueuesActor.getOrCreate([
+        "no-queues"
+      ]);
+      await _vitest.expect.call(void 0, 
+        handle.send("anyQueue", { value: "ignored" })
+      ).resolves.toBeUndefined();
+      await _vitest.expect.call(void 0, 
+        handle.send(
+          "anyQueue",
+          { value: "ignored-wait" },
+          { wait: true, timeout: 50 }
+        )
+      ).resolves.toMatchObject({ status: "completed" });
+      _vitest.expect.call(void 0, await handle.readAnyQueue()).toBeNull();
+    });
+    _vitest.test.call(void 0, "allows and denies subscriptions with canSubscribe", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlActor.getOrCreate([
+        "subscription"
+      ]);
+      const conn = handle.connect();
+      const allowedEventPromise = new Promise(
+        (resolve, reject) => {
+          const unsubscribeError = conn.onError((error) => {
+            reject(error);
+          });
+          const unsubscribeEvent = conn.on(
+            "allowedEvent",
+            (payload) => {
+              unsubscribeError();
+              unsubscribeEvent();
+              resolve(payload);
+            }
+          );
+        }
+      );
+      await conn.allowedAction("subscribe-ready");
+      await conn.allowedBroadcastAllowedEvent("hello");
+      _vitest.expect.call(void 0, await allowedEventPromise).toEqual({ value: "hello" });
+      const connId = await conn.allowedGetLastCanSubscribeConnId();
+      _vitest.expect.call(void 0, typeof connId).toBe("string");
+      _vitest.expect.call(void 0, connId.length).toBeGreaterThan(0);
+      await conn.dispose();
+      const blockedConn = handle.connect();
+      blockedConn.on("blockedEvent", () => {
+      });
+      await _vitest.expect.call(void 0, 
+        blockedConn.allowedAction("blocked-subscribe-ready")
+      ).rejects.toMatchObject({
+        code: "forbidden"
+      });
+      await blockedConn.dispose();
+    });
+    _vitest.test.call(void 0, "broadcasts undefined events without failing subscriptions", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.accessControlActor.getOrCreate([
+        "undefined-event"
+      ]);
+      const conn = handle.connect();
+      const eventPromise = new Promise((resolve, reject) => {
+        const unsubscribeError = conn.onError((error) => {
+          reject(error);
+        });
+        const unsubscribeEvent = conn.on("undefinedEvent", (payload) => {
+          unsubscribeError();
+          unsubscribeEvent();
+          resolve(payload);
+        });
+      });
+      await conn.allowedAction("undefined-subscribe-ready");
+      await conn.allowedBroadcastUndefinedEvent("wildcard");
+      _vitest.expect.call(void 0, await eventPromise).toEqual({ value: "wildcard" });
+      await conn.dispose();
+    });
+    _vitest.test.call(void 0, "allows and denies raw request handlers", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const allowedHandle = client.accessControlActor.getOrCreate(
+        ["raw-request-allow"],
+        {
+          params: { allowRequest: true }
+        }
+      );
+      const deniedHandle = client.accessControlActor.getOrCreate(
+        ["raw-request-deny"],
+        {
+          params: { allowRequest: false }
+        }
+      );
+      const allowedResponse = await allowedHandle.fetch("/status");
+      _vitest.expect.call(void 0, allowedResponse.status).toBe(200);
+      _vitest.expect.call(void 0, await allowedResponse.json()).toEqual({ ok: true });
+      const deniedResponse = await deniedHandle.fetch("/status");
+      _vitest.expect.call(void 0, deniedResponse.status).toBe(403);
+    });
+    _vitest.test.call(void 0, "allows and denies raw websocket handlers", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const allowedHandle = client.accessControlActor.getOrCreate(
+        ["raw-websocket-allow"],
+        {
+          params: { allowWebSocket: true }
+        }
+      );
+      const ws = await allowedHandle.webSocket();
+      const welcome = await new Promise((resolve) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve(
+              JSON.parse(event.data)
+            );
+          },
+          { once: true }
+        );
+      });
+      _vitest.expect.call(void 0, welcome.type).toBe("welcome");
+      ws.close();
+      const deniedHandle = client.accessControlActor.getOrCreate(
+        ["raw-websocket-deny"],
+        {
+          params: { allowWebSocket: false }
+        }
+      );
+      let denied = false;
+      try {
+        const deniedWs = await deniedHandle.webSocket();
+        const closeEvent = await new Promise((resolve) => {
+          deniedWs.addEventListener(
+            "close",
+            (event) => {
+              resolve(event);
+            },
+            { once: true }
+          );
+        });
+        _vitest.expect.call(void 0, closeEvent.code).toBe(1011);
+        denied = true;
+      } catch (e2) {
+        denied = true;
+      }
+      _vitest.expect.call(void 0, denied).toBe(true);
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-conn.ts
 
 function runActorConnTests(driverTestConfig) {
@@ -796,7 +989,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkXWBAQO5Hcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
         _vitest.expect.call(void 0, ping2).toBe("pong");
@@ -818,7 +1011,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkXWBAQO5Hcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
         _vitest.expect.call(void 0, count3).toBe(2);
@@ -840,7 +1033,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await conn1.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkXWBAQO5Hcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         await conn1.dispose();
         await waitFor(driverTestConfig, 250);
@@ -1046,6 +1239,329 @@ function runActorConnStateTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-db.ts
+
+var CHUNK_SIZE = 4096;
+var LARGE_PAYLOAD_SIZE = 32768;
+var HIGH_VOLUME_COUNT = 1e3;
+var SLEEP_WAIT_MS = 150;
+var LIFECYCLE_POLL_INTERVAL_MS = 25;
+var LIFECYCLE_POLL_ATTEMPTS = 40;
+var CHUNK_BOUNDARY_SIZES = [
+  CHUNK_SIZE - 1,
+  CHUNK_SIZE,
+  CHUNK_SIZE + 1,
+  2 * CHUNK_SIZE - 1,
+  2 * CHUNK_SIZE,
+  2 * CHUNK_SIZE + 1,
+  4 * CHUNK_SIZE - 1,
+  4 * CHUNK_SIZE,
+  4 * CHUNK_SIZE + 1
+];
+var SHRINK_GROW_INITIAL_ROWS = 16;
+var SHRINK_GROW_REGROW_ROWS = 10;
+var SHRINK_GROW_INITIAL_PAYLOAD = 4096;
+var SHRINK_GROW_REGROW_PAYLOAD = 6144;
+var HOT_ROW_COUNT = 10;
+var HOT_ROW_UPDATES = 240;
+var INTEGRITY_SEED_COUNT = 64;
+var INTEGRITY_CHURN_COUNT = 120;
+function getDbActor(client, variant) {
+  return variant === "raw" ? client.dbActorRaw : client.dbActorDrizzle;
+}
+function runActorDbTests(driverTestConfig) {
+  const variants = ["raw", "drizzle"];
+  for (const variant of variants) {
+    _vitest.describe.call(void 0, `Actor Database (${variant}) Tests`, () => {
+      _vitest.test.call(void 0, "bootstraps schema on startup", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-bootstrap-${crypto.randomUUID()}`
+        ]);
+        const count = await actor.getCount();
+        _vitest.expect.call(void 0, count).toBe(0);
+      });
+      _vitest.test.call(void 0, "supports CRUD, raw SQL, and multi-statement exec", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-crud-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        const first = await actor.insertValue("alpha");
+        const second = await actor.insertValue("beta");
+        const values = await actor.getValues();
+        _vitest.expect.call(void 0, values).toHaveLength(2);
+        _vitest.expect.call(void 0, values[0].value).toBe("alpha");
+        _vitest.expect.call(void 0, values[1].value).toBe("beta");
+        await actor.updateValue(first.id, "alpha-updated");
+        const updated = await actor.getValue(first.id);
+        _vitest.expect.call(void 0, updated).toBe("alpha-updated");
+        await actor.deleteValue(second.id);
+        const count = await actor.getCount();
+        _vitest.expect.call(void 0, count).toBe(1);
+        const rawCount = await actor.rawSelectCount();
+        _vitest.expect.call(void 0, rawCount).toBe(1);
+        const multiValue = await actor.multiStatementInsert("gamma");
+        _vitest.expect.call(void 0, multiValue).toBe("gamma-updated");
+      });
+      _vitest.test.call(void 0, "handles transactions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-tx-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        await actor.transactionCommit("commit");
+        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
+        await actor.transactionRollback("rollback");
+        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
+      });
+      _vitest.test.call(void 0, "persists across sleep and wake cycles", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-sleep-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        await actor.insertValue("sleepy");
+        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
+        for (let i = 0; i < 3; i++) {
+          await actor.triggerSleep();
+          await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+          _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
+        }
+      });
+      _vitest.test.call(void 0, "completes onDisconnect DB writes before sleeping", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const key = `db-${variant}-disconnect-${crypto.randomUUID()}`;
+        const actor = getDbActor(client, variant).getOrCreate([key]);
+        await actor.reset();
+        await actor.configureDisconnectInsert(true, 250);
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 250);
+        await actor.configureDisconnectInsert(false, 0);
+        _vitest.expect.call(void 0, await actor.getDisconnectInsertCount()).toBe(1);
+      });
+      _vitest.test.call(void 0, "handles high-volume inserts", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-high-volume-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        await actor.insertMany(HIGH_VOLUME_COUNT);
+        _vitest.expect.call(void 0, await actor.getCount()).toBe(HIGH_VOLUME_COUNT);
+      });
+      _vitest.test.call(void 0, "handles payloads across chunk boundaries", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-chunk-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        for (const size of CHUNK_BOUNDARY_SIZES) {
+          const { id } = await actor.insertPayloadOfSize(size);
+          const storedSize = await actor.getPayloadSize(id);
+          _vitest.expect.call(void 0, storedSize).toBe(size);
+        }
+      });
+      _vitest.test.call(void 0, "handles large payloads", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-large-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        const { id } = await actor.insertPayloadOfSize(LARGE_PAYLOAD_SIZE);
+        const storedSize = await actor.getPayloadSize(id);
+        _vitest.expect.call(void 0, storedSize).toBe(LARGE_PAYLOAD_SIZE);
+      });
+      _vitest.test.call(void 0, "supports shrink and regrow workloads with vacuum", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-shrink-regrow-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        await actor.vacuum();
+        const baselinePages = await actor.getPageCount();
+        await actor.insertPayloadRows(
+          SHRINK_GROW_INITIAL_ROWS,
+          SHRINK_GROW_INITIAL_PAYLOAD
+        );
+        const grownPages = await actor.getPageCount();
+        await actor.reset();
+        await actor.vacuum();
+        const shrunkPages = await actor.getPageCount();
+        await actor.insertPayloadRows(
+          SHRINK_GROW_REGROW_ROWS,
+          SHRINK_GROW_REGROW_PAYLOAD
+        );
+        const regrownPages = await actor.getPageCount();
+        _vitest.expect.call(void 0, grownPages).toBeGreaterThanOrEqual(baselinePages);
+        _vitest.expect.call(void 0, shrunkPages).toBeLessThanOrEqual(grownPages);
+        _vitest.expect.call(void 0, regrownPages).toBeGreaterThan(shrunkPages);
+      });
+      _vitest.test.call(void 0, "handles repeated updates to the same row", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-updates-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        const { id } = await actor.insertValue("base");
+        const result = await actor.repeatUpdate(id, 50);
+        _vitest.expect.call(void 0, result.value).toBe("Updated 49");
+        const value = await actor.getValue(id);
+        _vitest.expect.call(void 0, value).toBe("Updated 49");
+        const hotRowIds = [];
+        for (let i = 0; i < HOT_ROW_COUNT; i++) {
+          const row = await actor.insertValue(`init-${i}`);
+          hotRowIds.push(row.id);
+        }
+        const updatedRows = await actor.roundRobinUpdateValues(
+          hotRowIds,
+          HOT_ROW_UPDATES
+        );
+        _vitest.expect.call(void 0, updatedRows).toHaveLength(HOT_ROW_COUNT);
+        for (const row of updatedRows) {
+          _vitest.expect.call(void 0, row.value).toMatch(/^v-\d+$/);
+        }
+      });
+      _vitest.test.call(void 0, "passes integrity checks after mixed workload and sleep", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = getDbActor(client, variant).getOrCreate([
+          `db-${variant}-integrity-${crypto.randomUUID()}`
+        ]);
+        await actor.reset();
+        await actor.runMixedWorkload(
+          INTEGRITY_SEED_COUNT,
+          INTEGRITY_CHURN_COUNT
+        );
+        _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+        await actor.triggerSleep();
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+        _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+      });
+    });
+  }
+  _vitest.describe.call(void 0, "Actor Database Lifecycle Cleanup Tests", () => {
+    _vitest.test.call(void 0, "runs db provider cleanup on sleep", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+      const lifecycle = client.dbLifecycle.getOrCreate([
+        `db-lifecycle-sleep-${crypto.randomUUID()}`
+      ]);
+      const actorId = await lifecycle.getActorId();
+      const before = await observer.getCounts(actorId);
+      await lifecycle.insertValue("before-sleep");
+      await lifecycle.triggerSleep();
+      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+      await lifecycle.ping();
+      let after = before;
+      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+        after = await observer.getCounts(actorId);
+        if (after.cleanup >= before.cleanup + 1) {
+          break;
+        }
+        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+      }
+      _vitest.expect.call(void 0, after.create).toBeGreaterThanOrEqual(before.create);
+      _vitest.expect.call(void 0, after.migrate).toBeGreaterThanOrEqual(before.migrate);
+      _vitest.expect.call(void 0, after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+    });
+    _vitest.test.call(void 0, "runs db provider cleanup on destroy", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+      const lifecycle = client.dbLifecycle.getOrCreate([
+        `db-lifecycle-destroy-${crypto.randomUUID()}`
+      ]);
+      const actorId = await lifecycle.getActorId();
+      const before = await observer.getCounts(actorId);
+      await lifecycle.insertValue("before-destroy");
+      await lifecycle.triggerDestroy();
+      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+      let cleanupCount = before.cleanup;
+      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+        const counts = await observer.getCounts(actorId);
+        cleanupCount = counts.cleanup;
+        if (cleanupCount >= before.cleanup + 1) {
+          break;
+        }
+        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+      }
+      _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
+    });
+    _vitest.test.call(void 0, "runs db provider cleanup when migration fails", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+      const key = `db-lifecycle-migrate-failure-${crypto.randomUUID()}`;
+      const lifecycle = client.dbLifecycleFailing.getOrCreate([key]);
+      let threw = false;
+      try {
+        await lifecycle.ping();
+      } catch (e3) {
+        threw = true;
+      }
+      _vitest.expect.call(void 0, threw).toBeTruthy();
+      const actorId = await client.dbLifecycleFailing.get([key]).resolve();
+      let cleanupCount = 0;
+      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+        const counts = await observer.getCounts(actorId);
+        cleanupCount = counts.cleanup;
+        if (cleanupCount >= 1) {
+          break;
+        }
+        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+      }
+      _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(1);
+    });
+    _vitest.test.call(void 0, "handles parallel actor lifecycle churn", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+      const actorHandles = Array.from(
+        { length: 12 },
+        (_, i) => client.dbLifecycle.getOrCreate([
+          `db-lifecycle-stress-${i}-${crypto.randomUUID()}`
+        ])
+      );
+      const actorIds = await Promise.all(
+        actorHandles.map((handle) => handle.getActorId())
+      );
+      await Promise.all(
+        actorHandles.map((handle, i) => handle.insertValue(`phase-1-${i}`))
+      );
+      await Promise.all(actorHandles.map((handle) => handle.triggerSleep()));
+      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+      await Promise.all(
+        actorHandles.map((handle, i) => handle.insertValue(`phase-2-${i}`))
+      );
+      const survivors = actorHandles.slice(0, 6);
+      const destroyed = actorHandles.slice(6);
+      await Promise.all(destroyed.map((handle) => handle.triggerDestroy()));
+      await Promise.all(survivors.map((handle) => handle.triggerSleep()));
+      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+      await Promise.all(survivors.map((handle) => handle.ping()));
+      const survivorCounts = await Promise.all(
+        survivors.map((handle) => handle.getCount())
+      );
+      for (const count of survivorCounts) {
+        _vitest.expect.call(void 0, count).toBe(2);
+      }
+      const lifecycleCleanup = /* @__PURE__ */ new Map();
+      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+        let allCleaned = true;
+        for (const actorId of actorIds) {
+          const counts = await observer.getCounts(actorId);
+          lifecycleCleanup.set(actorId, counts.cleanup);
+          if (counts.cleanup < 1) {
+            allCleaned = false;
+          }
+        }
+        if (allCleaned) {
+          break;
+        }
+        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+      }
+      for (const actorId of actorIds) {
+        _vitest.expect.call(void 0, _nullishCoalesce(lifecycleCleanup.get(actorId), () => ( 0))).toBeGreaterThanOrEqual(1);
+      }
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-destroy.ts
 
 function runActorDestroyTests(driverTestConfig) {
@@ -1281,10 +1797,13 @@ function runActorScheduleTests(driverTestConfig) {
           await scheduled.scheduleTaskAfterWithId("third", 1250);
           await waitFor(driverTestConfig, 500);
           const history1 = await scheduled.getTaskHistory();
-          _vitest.expect.call(void 0, history1).toEqual(["first"]);
+          _vitest.expect.call(void 0, history1[0]).toBe("first");
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          _vitest.expect.call(void 0, history2).toEqual(["first", "second"]);
+          _vitest.expect.call(void 0, history2.slice(0, 2)).toEqual([
+            "first",
+            "second"
+          ]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
           _vitest.expect.call(void 0, history3).toEqual(["first", "second", "third"]);
@@ -1325,7 +1844,7 @@ function runActorSleepTests(driverTestConfig) {
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1341,7 +1860,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1357,7 +1876,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1373,19 +1892,19 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1400,8 +1919,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunk2IJTYN6Kcjs.SLEEP_TIMEOUT - 250);
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await sleepActor.setAlarm(_chunkXWBAQO5Hcjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1416,8 +1935,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 200);
+      await sleepActor.setAlarm(_chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1437,7 +1956,7 @@ function runActorSleepTests(driverTestConfig) {
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       await sleepActor.finishLongRunningRpc();
       await longRunningPromise;
       {
@@ -1446,7 +1965,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1465,7 +1984,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const ws = await sleepActor.websocket();
+      const ws = await sleepActor.webSocket();
       await new Promise((resolve, reject) => {
         ws.onopen = () => resolve();
         ws.onerror = reject;
@@ -1478,7 +1997,7 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       ws.send(JSON.stringify({ type: "getCounts" }));
       const counts = await new Promise((resolve) => {
         ws.onmessage = (event) => {
@@ -1491,7 +2010,7 @@ function runActorSleepTests(driverTestConfig) {
       _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
       _vitest.expect.call(void 0, counts.startCount).toBe(1);
       ws.close();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1509,7 +2028,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const fetchDuration = _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250;
+      const fetchDuration = _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
         `long-request?duration=${fetchDuration}`
       );
@@ -1522,7 +2041,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
         _vitest.expect.call(void 0, requestCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1537,13 +2056,13 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1639,8 +2158,8 @@ function runActorErrorHandlingTests(driverTestConfig) {
           await handle.throwInternalError();
           _vitest.expect.call(void 0, true).toBe(false);
         } catch (error) {
-          _vitest.expect.call(void 0, error.code).toBe(_chunk2XQS746Mcjs.INTERNAL_ERROR_CODE);
-          _vitest.expect.call(void 0, error.message).toBe(_chunk2XQS746Mcjs.INTERNAL_ERROR_DESCRIPTION);
+          _vitest.expect.call(void 0, error.code).toBe(_chunkL47L3ZWJcjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunkL47L3ZWJcjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -2000,7 +2519,197 @@ function runActorInlineClientTests(driverTestConfig) {
 // src/driver-test-suite/tests/actor-inspector.ts
 
 function runActorInspectorTests(driverTestConfig) {
-  _vitest.describe.skip("Actor Inspector Tests", () => {
+  _vitest.describe.call(void 0, "Actor Inspector HTTP API", () => {
+    _vitest.test.call(void 0, "GET /inspector/state returns actor state", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate(["inspector-state"]);
+      await handle.increment(5);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(`${gatewayUrl}/inspector/state`, {
+        headers: { Authorization: "Bearer token" }
+      });
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toEqual({ state: { count: 5 } });
+    });
+    _vitest.test.call(void 0, "PATCH /inspector/state updates actor state", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-set-state"
+      ]);
+      await handle.increment(5);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const patchResponse = await fetch(
+        `${gatewayUrl}/inspector/state`,
+        {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer token"
+          },
+          body: JSON.stringify({ state: { count: 42 } })
+        }
+      );
+      _vitest.expect.call(void 0, patchResponse.status).toBe(200);
+      const patchData = await patchResponse.json();
+      _vitest.expect.call(void 0, patchData).toEqual({ ok: true });
+      const count = await handle.getCount();
+      _vitest.expect.call(void 0, count).toBe(42);
+    });
+    _vitest.test.call(void 0, "GET /inspector/connections returns connections list", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-connections"
+      ]);
+      await handle.increment(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/connections`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toHaveProperty("connections");
+      _vitest.expect.call(void 0, Array.isArray(data.connections)).toBe(true);
+    });
+    _vitest.test.call(void 0, "GET /inspector/rpcs returns available actions", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate(["inspector-rpcs"]);
+      await handle.increment(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(`${gatewayUrl}/inspector/rpcs`, {
+        headers: { Authorization: "Bearer token" }
+      });
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toHaveProperty("rpcs");
+      _vitest.expect.call(void 0, data.rpcs).toContain("increment");
+      _vitest.expect.call(void 0, data.rpcs).toContain("getCount");
+      _vitest.expect.call(void 0, data.rpcs).toContain("setCount");
+    });
+    _vitest.test.call(void 0, "POST /inspector/action/:name executes an action", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-action"
+      ]);
+      await handle.increment(10);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/action/increment`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer token"
+          },
+          body: JSON.stringify({ args: [5] })
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.output).toBe(15);
+      const count = await handle.getCount();
+      _vitest.expect.call(void 0, count).toBe(15);
+    });
+    _vitest.test.call(void 0, "GET /inspector/queue returns queue status", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate(["inspector-queue"]);
+      await handle.increment(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/queue?limit=10`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toHaveProperty("size");
+      _vitest.expect.call(void 0, data).toHaveProperty("maxSize");
+      _vitest.expect.call(void 0, data).toHaveProperty("truncated");
+      _vitest.expect.call(void 0, data).toHaveProperty("messages");
+      _vitest.expect.call(void 0, typeof data.size).toBe("number");
+      _vitest.expect.call(void 0, typeof data.maxSize).toBe("number");
+      _vitest.expect.call(void 0, typeof data.truncated).toBe("boolean");
+      _vitest.expect.call(void 0, Array.isArray(data.messages)).toBe(true);
+    });
+    _vitest.test.call(void 0, "GET /inspector/traces returns trace data", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-traces"
+      ]);
+      await handle.increment(1);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/traces?startMs=0&endMs=${Date.now() + 6e4}&limit=100`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toHaveProperty("otlp");
+      _vitest.expect.call(void 0, data).toHaveProperty("clamped");
+      _vitest.expect.call(void 0, typeof data.clamped).toBe("boolean");
+    });
+    _vitest.test.call(void 0, "GET /inspector/workflow-history returns workflow status", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-workflow"
+      ]);
+      await handle.increment(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/workflow-history`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toHaveProperty("history");
+      _vitest.expect.call(void 0, data).toHaveProperty("isWorkflowEnabled");
+      _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(false);
+      _vitest.expect.call(void 0, data.history).toBeNull();
+    });
+    _vitest.test.call(void 0, "GET /inspector/summary returns full actor snapshot", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-summary"
+      ]);
+      await handle.increment(7);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/summary`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.state).toEqual({ count: 7 });
+      _vitest.expect.call(void 0, Array.isArray(data.connections)).toBe(true);
+      _vitest.expect.call(void 0, data.rpcs).toContain("increment");
+      _vitest.expect.call(void 0, typeof data.queueSize).toBe("number");
+      _vitest.expect.call(void 0, data.isStateEnabled).toBe(true);
+      _vitest.expect.call(void 0, typeof data.isDatabaseEnabled).toBe("boolean");
+      _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(false);
+      _vitest.expect.call(void 0, data.workflowHistory).toBeNull();
+    });
+    _vitest.test.call(void 0, "inspector endpoints require auth in non-dev mode", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate([
+        "inspector-auth"
+      ]);
+      await handle.increment(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(`${gatewayUrl}/inspector/state`, {
+        headers: { Authorization: "Bearer wrong-token" }
+      });
+      _vitest.expect.call(void 0, response.status).toBe(401);
+    });
   });
 }
 
@@ -2009,7 +2718,11 @@ function runActorInspectorTests(driverTestConfig) {
 function runActorKvTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor KV Tests", () => {
     _vitest.test.call(void 0, "supports text encoding and decoding", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
+      const { client: rawClient } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
+      const client = rawClient;
       const kvHandle = client.kvActor.getOrCreate(["kv-text"]);
       await kvHandle.putText("greeting", "hello");
       const value = await kvHandle.getText("greeting");
@@ -2026,8 +2739,14 @@ function runActorKvTests(driverTestConfig) {
     _vitest.test.call(void 0, 
       "supports arrayBuffer encoding and decoding",
       async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const kvHandle = client.kvActor.getOrCreate(["kv-array-buffer"]);
+        const { client: rawClient } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const client = rawClient;
+        const kvHandle = client.kvActor.getOrCreate([
+          "kv-array-buffer"
+        ]);
         const values = await kvHandle.roundtripArrayBuffer("bytes", [
           4,
           8,
@@ -2172,6 +2891,437 @@ function runActorOnStateChangeTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-queue.ts
+
+function runActorQueueTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Queue Tests", () => {
+    _vitest.test.call(void 0, "client can send to actor queue", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["client-send"]);
+      await handle.send("greeting", { hello: "world" });
+      const message = await handle.receiveOne("greeting");
+      _vitest.expect.call(void 0, message).toEqual({
+        name: "greeting",
+        body: { hello: "world" }
+      });
+    });
+    _vitest.test.call(void 0, "actor can send to its own queue", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["self-send"]);
+      await handle.sendToSelf("self", { value: 42 });
+      const message = await handle.receiveOne("self");
+      _vitest.expect.call(void 0, message).toEqual({ name: "self", body: { value: 42 } });
+    });
+    _vitest.test.call(void 0, "next supports name arrays and counts", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["receive-array"]);
+      await handle.send("a", 1);
+      await handle.send("b", 2);
+      await handle.send("c", 3);
+      const messages = await handle.receiveMany(["a", "b"], { count: 2 });
+      _vitest.expect.call(void 0, messages).toEqual([
+        { name: "a", body: 1 },
+        { name: "b", body: 2 }
+      ]);
+    });
+    _vitest.test.call(void 0, "next supports request objects", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["receive-request"]);
+      await handle.send("one", "first");
+      await handle.send("two", "second");
+      const messages = await handle.receiveRequest({
+        names: ["one", "two"],
+        count: 2
+      });
+      _vitest.expect.call(void 0, messages).toEqual([
+        { name: "one", body: "first" },
+        { name: "two", body: "second" }
+      ]);
+    });
+    _vitest.test.call(void 0, "next defaults to all names when names is omitted", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "receive-request-all"
+      ]);
+      await handle.send("one", "first");
+      await handle.send("two", "second");
+      const messages = await handle.receiveRequest({ count: 2 });
+      _vitest.expect.call(void 0, messages).toEqual([
+        { name: "one", body: "first" },
+        { name: "two", body: "second" }
+      ]);
+    });
+    _vitest.test.call(void 0, "next timeout returns empty array", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["receive-timeout"]);
+      const promise = handle.receiveMany(["missing"], { timeout: 50 });
+      await waitFor(driverTestConfig, 60);
+      const messages = await promise;
+      _vitest.expect.call(void 0, messages).toEqual([]);
+    });
+    _vitest.test.call(void 0, "tryNext does not wait and returns empty array", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["try-next-empty"]);
+      const messages = await handle.tryReceiveMany({
+        names: ["missing"],
+        count: 1
+      });
+      _vitest.expect.call(void 0, messages).toEqual([]);
+    });
+    _vitest.test.call(void 0, "abort throws ActorAborted", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["abort-test"]);
+      try {
+        await handle.waitForAbort();
+        _vitest.expect.fail("expected ActorAborted error");
+      } catch (error) {
+        _vitest.expect.call(void 0, error.group).toBe("actor");
+        _vitest.expect.call(void 0, error.code).toBe("aborted");
+      }
+    });
+    _vitest.test.call(void 0, "next supports signal abort", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["signal-abort-next"]);
+      const result = await handle.waitForSignalAbort();
+      _vitest.expect.call(void 0, result).toEqual({
+        group: "actor",
+        code: "aborted"
+      });
+    });
+    _vitest.test.call(void 0, "next supports actor abort when signal is provided", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "actor-abort-with-signal-next"
+      ]);
+      const result = await handle.waitForActorAbortWithSignal();
+      _vitest.expect.call(void 0, result).toEqual({
+        group: "actor",
+        code: "aborted"
+      });
+    });
+    _vitest.test.call(void 0, "iter supports signal abort", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["signal-abort-iter"]);
+      const result = await handle.iterWithSignalAbort();
+      _vitest.expect.call(void 0, result).toEqual({ ok: true });
+    });
+    _vitest.test.call(void 0, "enforces queue size limit", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const key = `size-limit-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+      const handle = client.queueLimitedActor.getOrCreate([key]);
+      await handle.send("message", 1);
+      await waitFor(driverTestConfig, 10);
+      try {
+        await handle.send("message", 2);
+        _vitest.expect.fail("expected queue full error");
+      } catch (error) {
+        _vitest.expect.call(void 0, error).toBeInstanceOf(Error);
+        _vitest.expect.call(void 0, error.message).toContain(
+          "Queue is full. Limit is"
+        );
+        if (driverTestConfig.clientType !== "http") {
+          _vitest.expect.call(void 0, error.group).toBe("queue");
+          _vitest.expect.call(void 0, error.code).toBe("full");
+        }
+      }
+    });
+    _vitest.test.call(void 0, "enforces message size limit", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueLimitedActor.getOrCreate([
+        "message-limit"
+      ]);
+      const largePayload = "a".repeat(200);
+      try {
+        await handle.send("oversize", largePayload);
+        _vitest.expect.fail("expected message_too_large error");
+      } catch (error) {
+        _vitest.expect.call(void 0, error.group).toBe("queue");
+        _vitest.expect.call(void 0, error.code).toBe("message_too_large");
+      }
+    });
+    _vitest.test.call(void 0, "wait send returns completion response", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["wait-complete"]);
+      const actionPromise = handle.receiveAndComplete("tasks");
+      const result = await handle.send(
+        "tasks",
+        { value: 123 },
+        { wait: true, timeout: 1e3 }
+      );
+      await actionPromise;
+      _vitest.expect.call(void 0, result).toEqual({
+        status: "completed",
+        response: { echo: { value: 123 } }
+      });
+    });
+    _vitest.test.call(void 0, "wait send times out", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["wait-timeout"]);
+      const resultPromise = handle.send(
+        "timeout",
+        { value: 456 },
+        { wait: true, timeout: 50 }
+      );
+      await waitFor(driverTestConfig, 60);
+      const result = await resultPromise;
+      _vitest.expect.call(void 0, result.status).toBe("timedOut");
+    });
+    _vitest.test.call(void 0, "manual receive retries message when not completed", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "manual-retry-uncompleted"
+      ]);
+      await handle.send("tasks", { value: 789 });
+      const first = await handle.receiveWithoutComplete("tasks");
+      _vitest.expect.call(void 0, first).toEqual({ name: "tasks", body: { value: 789 } });
+      const retried = await handle.receiveOne("tasks", { timeout: 1e3 });
+      _vitest.expect.call(void 0, retried).toEqual({ name: "tasks", body: { value: 789 } });
+    });
+    _vitest.test.call(void 0, "next throws when previous manual message is not completed", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "manual-next-requires-complete"
+      ]);
+      await handle.send("tasks", { value: 111 });
+      const result = await handle.receiveManualThenNextWithoutComplete(
+        "tasks"
+      );
+      _vitest.expect.call(void 0, result).toEqual({
+        group: "queue",
+        code: "previous_message_not_completed"
+      });
+    });
+    _vitest.test.call(void 0, "manual receive includes complete even without completion schema", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "complete-not-allowed"
+      ]);
+      await handle.send("nowait", { value: "test" });
+      const result = await handle.receiveWithoutCompleteMethod("nowait");
+      _vitest.expect.call(void 0, result).toEqual({
+        hasComplete: true
+      });
+    });
+    _vitest.test.call(void 0, "manual receive retries queues without completion schema until completed", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "complete-not-allowed-consume"
+      ]);
+      await handle.send("nowait", { value: "test" });
+      const result = await handle.receiveWithoutCompleteMethod("nowait");
+      _vitest.expect.call(void 0, result).toEqual({ hasComplete: true });
+      const next = await handle.receiveOne("nowait", { timeout: 1e3 });
+      _vitest.expect.call(void 0, next).toEqual({ name: "nowait", body: { value: "test" } });
+    });
+    _vitest.test.call(void 0, "complete throws when called twice", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "complete-twice"
+      ]);
+      await handle.send("twice", { value: "test" });
+      const result = await handle.receiveAndCompleteTwice("twice");
+      _vitest.expect.call(void 0, result).toEqual({
+        group: "queue",
+        code: "already_completed"
+      });
+    });
+    _vitest.test.call(void 0, "wait send no longer requires queue completion schema", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "missing-completion-schema"
+      ]);
+      const result = await handle.send(
+        "nowait",
+        { value: "test" },
+        { wait: true, timeout: 50 }
+      );
+      _vitest.expect.call(void 0, result).toEqual({ status: "timedOut" });
+    });
+    _vitest.test.call(void 0, "iter can consume queued messages", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["iter-consume"]);
+      await handle.send("one", "first");
+      const message = await handle.receiveWithIterator("one");
+      _vitest.expect.call(void 0, message).toEqual({ name: "one", body: "first" });
+    });
+    _vitest.test.call(void 0, "queue async iterator can consume queued messages", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate([
+        "async-iter-consume"
+      ]);
+      await handle.send("two", "second");
+      const message = await handle.receiveWithAsyncIterator();
+      _vitest.expect.call(void 0, message).toEqual({ name: "two", body: "second" });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-run.ts
+
+function runActorRunTests(driverTestConfig) {
+  var _a;
+  _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Run Tests", () => {
+    _vitest.test.call(void 0, "run handler starts after actor startup", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithTicks.getOrCreate(["run-starts"]);
+      await waitFor(driverTestConfig, 100);
+      const state = await actor.getState();
+      _vitest.expect.call(void 0, state.runStarted).toBe(true);
+      _vitest.expect.call(void 0, state.tickCount).toBeGreaterThan(0);
+    });
+    _vitest.test.call(void 0, "run handler ticks continuously", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithTicks.getOrCreate(["run-ticks"]);
+      await waitFor(driverTestConfig, 200);
+      const state1 = await actor.getState();
+      _vitest.expect.call(void 0, state1.tickCount).toBeGreaterThan(0);
+      const count1 = state1.tickCount;
+      await waitFor(driverTestConfig, 200);
+      const state2 = await actor.getState();
+      _vitest.expect.call(void 0, state2.tickCount).toBeGreaterThan(count1);
+    });
+    _vitest.test.call(void 0, "active run handler keeps actor awake past sleep timeout", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithTicks.getOrCreate([
+        "run-stays-awake"
+      ]);
+      await waitFor(driverTestConfig, 100);
+      const state1 = await actor.getState();
+      _vitest.expect.call(void 0, state1.runStarted).toBe(true);
+      const tickCount1 = state1.tickCount;
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.RUN_SLEEP_TIMEOUT + 300);
+      const state2 = await actor.getState();
+      _vitest.expect.call(void 0, state2.runStarted).toBe(true);
+      _vitest.expect.call(void 0, state2.runExited).toBe(false);
+      _vitest.expect.call(void 0, state2.tickCount).toBeGreaterThan(tickCount1);
+    });
+    _vitest.test.call(void 0, "actor without run handler works normally", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithoutHandler.getOrCreate([
+        "no-run-handler"
+      ]);
+      const state = await actor.getState();
+      _vitest.expect.call(void 0, state.wakeCount).toBe(1);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.RUN_SLEEP_TIMEOUT + 300);
+      const state2 = await actor.getState();
+      _vitest.expect.call(void 0, state2.wakeCount).toBe(2);
+    });
+    _vitest.test.call(void 0, "run handler can consume from queue", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithQueueConsumer.getOrCreate([
+        "queue-consumer"
+      ]);
+      await waitFor(driverTestConfig, 100);
+      await actor.sendMessage({ type: "test", value: 1 });
+      await actor.sendMessage({ type: "test", value: 2 });
+      await actor.sendMessage({ type: "test", value: 3 });
+      await waitFor(driverTestConfig, 1200);
+      const state = await actor.getState();
+      _vitest.expect.call(void 0, state.runStarted).toBe(true);
+      _vitest.expect.call(void 0, state.messagesReceived.length).toBe(3);
+      _vitest.expect.call(void 0, state.messagesReceived[0].body).toEqual({
+        type: "test",
+        value: 1
+      });
+      _vitest.expect.call(void 0, state.messagesReceived[1].body).toEqual({
+        type: "test",
+        value: 2
+      });
+      _vitest.expect.call(void 0, state.messagesReceived[2].body).toEqual({
+        type: "test",
+        value: 3
+      });
+    });
+    _vitest.test.call(void 0, "queue-waiting run handler can sleep and resume", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithQueueConsumer.getOrCreate([
+        "queue-consumer-sleep"
+      ]);
+      await waitFor(driverTestConfig, 100);
+      const state1 = await actor.getState();
+      _vitest.expect.call(void 0, state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, _chunkXWBAQO5Hcjs.RUN_SLEEP_TIMEOUT + 500);
+      const state2 = await actor.getState();
+      _vitest.expect.call(void 0, state2.wakeCount).toBeGreaterThan(state1.wakeCount);
+    });
+    _vitest.test.call(void 0, "run handler that exits early triggers destroy", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithEarlyExit.getOrCreate(["early-exit"]);
+      await waitFor(driverTestConfig, 100);
+      const state1 = await actor.getState();
+      _vitest.expect.call(void 0, state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, 300);
+      const actor2 = client.runWithEarlyExit.getOrCreate([
+        "early-exit-fresh"
+      ]);
+      const state2 = await actor2.getState();
+      _vitest.expect.call(void 0, state2.runStarted).toBe(true);
+    });
+    _vitest.test.call(void 0, "run handler that throws error triggers destroy", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.runWithError.getOrCreate(["run-error"]);
+      await waitFor(driverTestConfig, 100);
+      const state1 = await actor.getState();
+      _vitest.expect.call(void 0, state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, 300);
+      const actor2 = client.runWithError.getOrCreate(["run-error-fresh"]);
+      const state2 = await actor2.getState();
+      _vitest.expect.call(void 0, state2.runStarted).toBe(true);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-stateless.ts
+
+function runActorStatelessTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Stateless Tests", () => {
+    _vitest.describe.call(void 0, "Stateless Actor Operations", () => {
+      _vitest.test.call(void 0, "can call actions on stateless actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.ping();
+        _vitest.expect.call(void 0, result).toBe("pong");
+      });
+      _vitest.test.call(void 0, "can echo messages", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const message = "Hello, World!";
+        const result = await instance.echo(message);
+        _vitest.expect.call(void 0, result).toBe(message);
+      });
+      _vitest.test.call(void 0, "can access actorId", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate(["test-id"]);
+        const actorId = await instance.getActorId();
+        _vitest.expect.call(void 0, actorId).toBeDefined();
+        _vitest.expect.call(void 0, typeof actorId).toBe("string");
+      });
+      _vitest.test.call(void 0, "accessing state throws StateNotEnabled", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.tryGetState();
+        _vitest.expect.call(void 0, result.success).toBe(false);
+        _vitest.expect.call(void 0, result.error).toContain("state");
+      });
+      _vitest.test.call(void 0, "accessing db throws DatabaseNotEnabled", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.tryGetDb();
+        _vitest.expect.call(void 0, result.success).toBe(false);
+        _vitest.expect.call(void 0, result.error).toContain("database");
+      });
+      _vitest.test.call(void 0, "multiple stateless actors can exist independently", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor1 = client.statelessActor.getOrCreate(["actor-1"]);
+        const actor2 = client.statelessActor.getOrCreate(["actor-2"]);
+        const id1 = await actor1.getActorId();
+        const id2 = await actor2.getActorId();
+        _vitest.expect.call(void 0, id1).not.toBe(id2);
+      });
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-vars.ts
 
 function runActorVarsTests(driverTestConfig) {
@@ -2236,6 +3386,89 @@ function runActorVarsTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-workflow.ts
+
+function runActorWorkflowTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Workflow Tests", () => {
+    var _a;
+    _vitest.test.call(void 0, "replays steps and guards state access", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowCounterActor.getOrCreate([
+        "workflow-basic"
+      ]);
+      await waitFor(driverTestConfig, 1e3);
+      const state = await actor.getState();
+      _vitest.expect.call(void 0, state.runCount).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, state.history.length).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, state.guardTriggered).toBe(true);
+    });
+    _vitest.test.call(void 0, "consumes queue messages via workflow queue.next", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowQueueActor.getOrCreate(["workflow-queue"]);
+      await actor.send(_chunkXWBAQO5Hcjs.WORKFLOW_QUEUE_NAME, {
+        hello: "world"
+      });
+      await waitFor(driverTestConfig, 200);
+      const messages = await actor.getMessages();
+      _vitest.expect.call(void 0, messages).toEqual([{ hello: "world" }]);
+    });
+    _vitest.test.call(void 0, "workflow queue.next supports completing wait sends", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowQueueActor.getOrCreate([
+        "workflow-queue-wait"
+      ]);
+      const result = await actor.sendAndWait({ value: 123 });
+      _vitest.expect.call(void 0, result).toEqual({
+        status: "completed",
+        response: { echo: { value: 123 } }
+      });
+    });
+    _vitest.test.call(void 0, "db and client are step-only in workflow context", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowAccessActor.getOrCreate([
+        "workflow-access"
+      ]);
+      let state = await actor.getState();
+      for (let i = 0; i < 20 && state.insideDbCount === 0; i++) {
+        await waitFor(driverTestConfig, 50);
+        state = await actor.getState();
+      }
+      _vitest.expect.call(void 0, state.outsideDbError).toBe(
+        "db is only available inside workflow steps"
+      );
+      _vitest.expect.call(void 0, state.outsideClientError).toBe(
+        "client is only available inside workflow steps"
+      );
+      _vitest.expect.call(void 0, state.insideDbCount).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, state.insideClientAvailable).toBe(true);
+    });
+    _vitest.test.call(void 0, "sleeps and resumes between ticks", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowSleepActor.getOrCreate(["workflow-sleep"]);
+      const initial = await actor.getState();
+      await waitFor(driverTestConfig, 200);
+      const next = await actor.getState();
+      _vitest.expect.call(void 0, next.ticks).toBeGreaterThan(initial.ticks);
+    });
+    _vitest.test.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)(
+      "workflow run teardown does not wait for runStopTimeout",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.workflowStopTeardownActor.getOrCreate([
+          "workflow-stop-teardown"
+        ]);
+        await actor.getTimeline();
+        await waitFor(driverTestConfig, 1200);
+        const timeline = await actor.getTimeline();
+        _vitest.expect.call(void 0, timeline.wakeAts.length).toBeGreaterThanOrEqual(2);
+        _vitest.expect.call(void 0, timeline.sleepAts.length).toBeGreaterThanOrEqual(1);
+        const firstSleepDelayMs = timeline.sleepAts[0] - timeline.wakeAts[0];
+        _vitest.expect.call(void 0, firstSleepDelayMs).toBeLessThan(1800);
+      }
+    );
+  });
+}
+
 // src/driver-test-suite/tests/manager-driver.ts
 
 function runManagerDriverTests(driverTestConfig) {
@@ -2355,6 +3588,12 @@ function runManagerDriverTests(driverTestConfig) {
       });
     });
     _vitest.describe.call(void 0, "Key Matching", () => {
+      _vitest.test.call(void 0, "multi-part actor keys are passed through correctly", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const multiPartKey = ["tenant/with/slash", "room"];
+        const counter = client.counter.getOrCreate(multiPartKey);
+        _vitest.expect.call(void 0, await counter.getKey()).toEqual(multiPartKey);
+      });
       _vitest.test.call(void 0, "matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
@@ -2536,7 +3775,7 @@ function runRawHttpTests(driverTestConfig) {
         _vitest.expect.call(void 0, errorData.message).toContain(
           "onRequest handler must return a Response"
         );
-      } catch (e2) {
+      } catch (e4) {
       }
     });
     _vitest.test.call(void 0, "should handle different HTTP methods", async (c) => {
@@ -3071,7 +4310,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["basic"]);
-      const ws = await actor.websocket();
+      const ws = await actor.webSocket();
       await new Promise((resolve) => {
         if (ws.readyState === WebSocket.OPEN) {
           resolve();
@@ -3102,7 +4341,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["echo"]);
-      const ws = await actor.websocket();
+      const ws = await actor.webSocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3133,7 +4372,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["ping"]);
-      const ws = await actor.websocket();
+      const ws = await actor.webSocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3163,7 +4402,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should track stats across connections", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
-      const ws1 = await actor1.websocket();
+      const ws1 = await actor1.webSocket();
       const ws1MessagePromise = new Promise((resolve, reject) => {
         ws1.addEventListener("message", () => resolve(), {
           once: true
@@ -3172,7 +4411,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       await ws1MessagePromise;
       const actor2 = client.rawWebSocketActor.get(["stats"]);
-      const ws2 = await actor2.websocket();
+      const ws2 = await actor2.webSocket();
       const ws2MessagePromise = new Promise((resolve, reject) => {
         ws2.addEventListener("message", () => resolve(), {
           once: true
@@ -3217,7 +4456,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor = client.rawWebSocketBinaryActor.getOrCreate([
         "binary"
       ]);
-      const ws = await actor.websocket();
+      const ws = await actor.webSocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3262,7 +4501,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should work with custom paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["paths"]);
-      const ws = await actor.websocket("custom/path");
+      const ws = await actor.webSocket("custom/path");
       await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => {
           resolve();
@@ -3285,7 +4524,7 @@ function runRawWebSocketTests(driverTestConfig) {
     _vitest.test.call(void 0, "should handle connection close properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["close-test"]);
-      const ws = await actor.websocket();
+      const ws = await actor.webSocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3316,7 +4555,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor = client.rawWebSocketActor.getOrCreate([
         "open-close-test"
       ]);
-      const ws1 = await actor.websocket();
+      const ws1 = await actor.webSocket();
       await new Promise((resolve, reject) => {
         ws1.addEventListener("open", () => resolve(), { once: true });
         ws1.addEventListener("close", reject);
@@ -3333,7 +4572,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       _vitest.expect.call(void 0, welcome1.type).toBe("welcome");
       _vitest.expect.call(void 0, welcome1.connectionCount).toBe(1);
-      const ws2 = await actor.websocket();
+      const ws2 = await actor.webSocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
         ws2.addEventListener("close", reject);
@@ -3384,7 +4623,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor = client.rawWebSocketActor.getOrCreate([
         "query-params"
       ]);
-      const ws = await actor.websocket(
+      const ws = await actor.webSocket(
         "api/v1/stream?token=abc123&user=test"
       );
       await new Promise((resolve, reject) => {
@@ -3412,7 +4651,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor = client.rawWebSocketActor.getOrCreate([
         "base-path-query-params"
       ]);
-      const ws = await actor.websocket("?token=secret&session=123");
+      const ws = await actor.webSocket("?token=secret&session=123");
       await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => resolve(), { once: true });
         ws.addEventListener("error", reject);
@@ -3527,41 +4766,49 @@ function runRequestAccessTests(driverTestConfig) {
 
 // src/driver-test-suite/mod.ts
 function runDriverTests(driverTestConfigPartial) {
-  var _a;
-  const clientTypes = ((_a = driverTestConfigPartial.skip) == null ? void 0 : _a.inline) ? ["http"] : ["http", "inline"];
-  for (const clientType of clientTypes) {
-    _vitest.describe.call(void 0, `client type (${clientType})`, () => {
-      const encodings = ["bare", "cbor", "json"];
-      for (const encoding of encodings) {
-        _vitest.describe.call(void 0, `encoding (${encoding})`, () => {
-          const driverTestConfig = {
-            ...driverTestConfigPartial,
-            clientType,
-            encoding
-          };
-          runActorDriverTests(driverTestConfig);
-          runManagerDriverTests(driverTestConfig);
-          runActorConnTests(driverTestConfig);
-          runActorConnStateTests(driverTestConfig);
-          runActorConnHibernationTests(driverTestConfig);
-          runActorDestroyTests(driverTestConfig);
-          runRequestAccessTests(driverTestConfig);
-          runActorHandleTests(driverTestConfig);
-          runActionFeaturesTests(driverTestConfig);
-          runActorVarsTests(driverTestConfig);
-          runActorMetadataTests(driverTestConfig);
-          runActorOnStateChangeTests(driverTestConfig);
-          runActorErrorHandlingTests(driverTestConfig);
-          runActorInlineClientTests(driverTestConfig);
-          runActorKvTests(driverTestConfig);
-          runRawHttpTests(driverTestConfig);
-          runRawHttpRequestPropertiesTests(driverTestConfig);
-          runRawWebSocketTests(driverTestConfig);
-          runActorInspectorTests(driverTestConfig);
-        });
-      }
-    });
-  }
+  _vitest.describe.call(void 0, "Driver Tests", () => {
+    var _a;
+    const clientTypes = ((_a = driverTestConfigPartial.skip) == null ? void 0 : _a.inline) ? ["http"] : ["http", "inline"];
+    for (const clientType of clientTypes) {
+      _vitest.describe.call(void 0, `client type (${clientType})`, () => {
+        const encodings = ["bare", "cbor", "json"];
+        for (const encoding of encodings) {
+          _vitest.describe.call(void 0, `encoding (${encoding})`, () => {
+            const driverTestConfig = {
+              ...driverTestConfigPartial,
+              clientType,
+              encoding
+            };
+            runActorDriverTests(driverTestConfig);
+            runManagerDriverTests(driverTestConfig);
+            runActorConnTests(driverTestConfig);
+            runActorConnStateTests(driverTestConfig);
+            runActorConnHibernationTests(driverTestConfig);
+            runActorDbTests(driverTestConfig);
+            runActorDestroyTests(driverTestConfig);
+            runRequestAccessTests(driverTestConfig);
+            runActorHandleTests(driverTestConfig);
+            runActionFeaturesTests(driverTestConfig);
+            runAccessControlTests(driverTestConfig);
+            runActorVarsTests(driverTestConfig);
+            runActorMetadataTests(driverTestConfig);
+            runActorOnStateChangeTests(driverTestConfig);
+            runActorErrorHandlingTests(driverTestConfig);
+            runActorQueueTests(driverTestConfig);
+            runActorRunTests(driverTestConfig);
+            runActorInlineClientTests(driverTestConfig);
+            runActorKvTests(driverTestConfig);
+            runActorWorkflowTests(driverTestConfig);
+            runActorStatelessTests(driverTestConfig);
+            runRawHttpTests(driverTestConfig);
+            runRawHttpRequestPropertiesTests(driverTestConfig);
+            runRawWebSocketTests(driverTestConfig);
+            runActorInspectorTests(driverTestConfig);
+          });
+        }
+      });
+    }
+  });
 }
 async function createTestRuntime(registryPath, driverFactory) {
   var _a;
@@ -3591,7 +4838,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     const parsedConfig = registry.parseConfig();
     const managerDriver = (_a = driver.manager) == null ? void 0 : _a.call(driver, parsedConfig);
     _invariant2.default.call(void 0, managerDriver, "missing manager driver");
-    const { router } = _chunkRZW2DNNDcjs.buildManagerRouter.call(void 0, 
+    const { router } = _chunkF6JYU5IKcjs.buildManagerRouter.call(void 0, 
       parsedConfig,
       managerDriver,
       () => upgradeWebSocket
@@ -3599,19 +4846,26 @@ async function createTestRuntime(registryPath, driverFactory) {
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
     managerDriver.setGetUpgradeWebSocket(() => upgradeWebSocket);
-    const port = await _chunk3VP5CSHVcjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",
-      port
+      port: 0
     });
+    if (!server.listening) {
+      await new Promise((resolve) => {
+        server.once("listening", () => resolve());
+      });
+    }
     _invariant2.default.call(void 0, 
       nodeWebSocket.injectWebSocket !== void 0,
       "should have injectWebSocket"
     );
     nodeWebSocket.injectWebSocket(server);
+    const address = server.address();
+    _invariant2.default.call(void 0, address && typeof address !== "string", "missing server address");
+    const port = address.port;
     const serverEndpoint = `http://127.0.0.1:${port}`;
-    _chunk2IJTYN6Kcjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
+    _chunkXWBAQO5Hcjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
     const cleanup = async () => {
       await new Promise(
         (resolve) => server.close(() => resolve(void 0))