rivetkit 2.0.42 → 2.1.0-rc.1

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

@@ -1,22 +1,25 @@
 import {
   HIBERNATION_SLEEP_TIMEOUT,
+  RUN_SLEEP_TIMEOUT,
   SLEEP_TIMEOUT,
+  WORKFLOW_QUEUE_NAME,
   logger
-} from "../chunk-TCOEBUUE.js";
-import {
-  getPort
-} from "../chunk-AQFSQMBG.js";
-import "../chunk-JDAD2YFA.js";
-import "../chunk-KCOVZOPS.js";
+} from "../chunk-OMEPCQK2.js";
+import "../chunk-7K4CYDGD.js";
+import "../chunk-IVG73YCW.js";
+import "../chunk-5ESWDTHJ.js";
+import "../chunk-MZ37VV3P.js";
 import {
   ActorError,
   ClientConfigSchema,
   createClient,
   createClientWithDriver
-} from "../chunk-Q6W7RJJP.js";
+} from "../chunk-DIGBC2VI.js";
 import {
   importWebSocket
-} from "../chunk-XXGJCOL6.js";
+} from "../chunk-A6YIZWTK.js";
+import "../chunk-KJSYAUOM.js";
+import "../chunk-N4KRDJ56.js";
 import {
   HEADER_ACTOR_ID,
   WS_PROTOCOL_ACTOR,
@@ -25,23 +28,26 @@ import {
   WS_PROTOCOL_STANDARD,
   WS_PROTOCOL_TARGET,
   WS_TEST_PROTOCOL_PATH,
-  assertUnreachable,
   buildManagerRouter
-} from "../chunk-GMAVRZSF.js";
-import "../chunk-E6ZE2YEA.js";
+} from "../chunk-M2T62AZQ.js";
+import "../chunk-LXUQ667X.js";
+import {
+  assertUnreachable
+} from "../chunk-T5YCUGVS.js";
 import {
   noopNext
-} from "../chunk-FJ3KTN4V.js";
+} from "../chunk-6LIBPELE.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-LFVF5SCU.js";
+} from "../chunk-7HTNH26M.js";
+import "../chunk-424PT5DM.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket } from "@hono/node-ws";
 import invariant2 from "invariant";
-import { describe as describe23 } from "vitest";
+import { describe as describe29 } from "vitest";
 
 // src/driver-test-suite/tests/action-features.ts
 import { describe, expect, test } from "vitest";
@@ -403,21 +409,209 @@ function runActionFeaturesTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/access-control.ts
+import { describe as describe2, expect as expect2, test as test2 } from "vitest";
+function runAccessControlTests(driverTestConfig) {
+  describe2("access control", () => {
+    test2("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");
+      expect2(allowed).toBe("allowed:ok");
+    });
+    test2("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();
+      expect2(typeof connId).toBe("string");
+      expect2(connId.length).toBeGreaterThan(0);
+    });
+    test2("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 expect2(
+        handle.send("blockedQueue", { value: "two" })
+      ).rejects.toMatchObject({
+        code: "forbidden"
+      });
+      await expect2(
+        handle.send("missingQueue", { value: "three" })
+      ).resolves.toBeUndefined();
+      await expect2(
+        handle.send(
+          "missingQueue",
+          { value: "four" },
+          { wait: true, timeout: 50 }
+        )
+      ).resolves.toMatchObject({ status: "completed" });
+      const allowedMessage = await handle.allowedReceiveQueue();
+      expect2(allowedMessage).toEqual({ value: "one" });
+      const remainingMessage = await handle.allowedReceiveAnyQueue();
+      expect2(remainingMessage).toBeNull();
+    });
+    test2("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 expect2(
+        handle.send("anyQueue", { value: "ignored" })
+      ).resolves.toBeUndefined();
+      await expect2(
+        handle.send(
+          "anyQueue",
+          { value: "ignored-wait" },
+          { wait: true, timeout: 50 }
+        )
+      ).resolves.toMatchObject({ status: "completed" });
+      expect2(await handle.readAnyQueue()).toBeNull();
+    });
+    test2("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");
+      expect2(await allowedEventPromise).toEqual({ value: "hello" });
+      const connId = await conn.allowedGetLastCanSubscribeConnId();
+      expect2(typeof connId).toBe("string");
+      expect2(connId.length).toBeGreaterThan(0);
+      await conn.dispose();
+      const blockedConn = handle.connect();
+      blockedConn.on("blockedEvent", () => {
+      });
+      await expect2(
+        blockedConn.allowedAction("blocked-subscribe-ready")
+      ).rejects.toMatchObject({
+        code: "forbidden"
+      });
+      await blockedConn.dispose();
+    });
+    test2("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");
+      expect2(await eventPromise).toEqual({ value: "wildcard" });
+      await conn.dispose();
+    });
+    test2("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");
+      expect2(allowedResponse.status).toBe(200);
+      expect2(await allowedResponse.json()).toEqual({ ok: true });
+      const deniedResponse = await deniedHandle.fetch("/status");
+      expect2(deniedResponse.status).toBe(403);
+    });
+    test2("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 }
+        );
+      });
+      expect2(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 }
+          );
+        });
+        expect2(closeEvent.code).toBe(1011);
+        denied = true;
+      } catch {
+        denied = true;
+      }
+      expect2(denied).toBe(true);
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-conn.ts
-import { describe as describe2, expect as expect2, test as test2, vi as vi2 } from "vitest";
+import { describe as describe3, expect as expect3, test as test3, vi as vi2 } from "vitest";
 function runActorConnTests(driverTestConfig) {
-  describe2("Actor Connection Tests", () => {
-    describe2("Connection Methods", () => {
-      test2("should connect using .get().connect()", async (c) => {
+  describe3("Actor Connection Tests", () => {
+    describe3("Connection Methods", () => {
+      test3("should connect using .get().connect()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         await client.counter.create(["test-get"]);
         const handle = client.counter.get(["test-get"]);
         const connection = handle.connect();
         const count = await connection.increment(5);
-        expect2(count).toBe(5);
+        expect3(count).toBe(5);
         await connection.dispose();
       });
-      test2("should connect using .getForId().connect()", async (c) => {
+      test3("should connect using .getForId().connect()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-get-for-id"]);
         await handle.increment(3);
@@ -425,30 +619,30 @@ function runActorConnTests(driverTestConfig) {
         const idHandle = client.counter.getForId(actorId);
         const connection = idHandle.connect();
         const count = await connection.getCount();
-        expect2(count).toBe(3);
+        expect3(count).toBe(3);
         await connection.dispose();
       });
-      test2("should connect using .getOrCreate().connect()", async (c) => {
+      test3("should connect using .getOrCreate().connect()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-get-or-create"
         ]);
         const connection = handle.connect();
         const count = await connection.increment(7);
-        expect2(count).toBe(7);
+        expect3(count).toBe(7);
         await connection.dispose();
       });
-      test2("should connect using (await create()).connect()", async (c) => {
+      test3("should connect using (await create()).connect()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-create"]);
         const connection = handle.connect();
         const count = await connection.increment(9);
-        expect2(count).toBe(9);
+        expect3(count).toBe(9);
         await connection.dispose();
       });
     });
-    describe2("Event Communication", () => {
-      test2("should mix RPC calls and WebSocket events", async (c) => {
+    describe3("Event Communication", () => {
+      test3("should mix RPC calls and WebSocket events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-mixed-rpc-ws"
@@ -460,17 +654,17 @@ function runActorConnTests(driverTestConfig) {
         });
         await vi2.waitFor(async () => {
           await connection.setCount(1);
-          expect2(receivedEvents).includes(1);
+          expect3(receivedEvents).includes(1);
         });
         await handle.setCount(2);
         await handle.setCount(3);
         await vi2.waitFor(() => {
-          expect2(receivedEvents).includes(2);
-          expect2(receivedEvents).includes(3);
+          expect3(receivedEvents).includes(2);
+          expect3(receivedEvents).includes(3);
         });
         await connection.dispose();
       });
-      test2("should receive events via broadcast", async (c) => {
+      test3("should receive events via broadcast", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-broadcast"]);
         const connection = handle.connect();
@@ -482,14 +676,14 @@ function runActorConnTests(driverTestConfig) {
           async () => {
             await connection.setCount(5);
             await connection.setCount(8);
-            expect2(receivedEvents).toContain(5);
-            expect2(receivedEvents).toContain(8);
+            expect3(receivedEvents).toContain(5);
+            expect3(receivedEvents).toContain(8);
           },
           { timeout: 1e4 }
         );
         await connection.dispose();
       });
-      test2("should handle one-time events with once()", async (c) => {
+      test3("should handle one-time events with once()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-once"]);
         const connection = handle.connect();
@@ -500,12 +694,12 @@ function runActorConnTests(driverTestConfig) {
         await connection.increment(5);
         await connection.increment(3);
         await vi2.waitFor(() => {
-          expect2(receivedEvents).toEqual([5]);
-          expect2(receivedEvents).not.toContain(8);
+          expect3(receivedEvents).toEqual([5]);
+          expect3(receivedEvents).not.toContain(8);
         });
         await connection.dispose();
       });
-      test2("should unsubscribe from events", async (c) => {
+      test3("should unsubscribe from events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-unsubscribe"]);
         const connection = handle.connect();
@@ -518,16 +712,16 @@ function runActorConnTests(driverTestConfig) {
         );
         await vi2.waitFor(async () => {
           await connection.setCount(5);
-          expect2(receivedEvents).toEqual([5]);
+          expect3(receivedEvents).toEqual([5]);
         });
         unsubscribe();
         await connection.setCount(8);
-        expect2(receivedEvents).not.toContain(8);
+        expect3(receivedEvents).not.toContain(8);
         await connection.dispose();
       });
     });
-    describe2("Connection Parameters", () => {
-      test2("should pass connection parameters", async (c) => {
+    describe3("Connection Parameters", () => {
+      test3("should pass connection parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle1 = client.counterWithParams.getOrCreate(
           ["test-params"],
@@ -546,14 +740,14 @@ function runActorConnTests(driverTestConfig) {
         await conn1.getInitializers();
         await conn2.getInitializers();
         const initializers = await conn1.getInitializers();
-        expect2(initializers).toContain("user1");
-        expect2(initializers).toContain("user2");
+        expect3(initializers).toContain("user1");
+        expect3(initializers).toContain("user2");
         await conn1.dispose();
         await conn2.dispose();
       });
     });
-    describe2("Lifecycle Hooks", () => {
-      test2("should trigger lifecycle hooks", async (c) => {
+    describe3("Lifecycle Hooks", () => {
+      test3("should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -563,7 +757,7 @@ function runActorConnTests(driverTestConfig) {
         );
         const connection = connHandle.connect();
         const events = await connection.getEvents();
-        expect2(events).toEqual([
+        expect3(events).toEqual([
           "onWake",
           "onBeforeConnect",
           "onConnect"
@@ -575,7 +769,7 @@ function runActorConnTests(driverTestConfig) {
               "test-lifecycle"
             ]);
             const finalEvents = await handle.getEvents();
-            expect2(finalEvents).toBeOneOf([
+            expect3(finalEvents).toBeOneOf([
               // Still active
               [
                 "onWake",
@@ -601,20 +795,20 @@ function runActorConnTests(driverTestConfig) {
         );
       });
     });
-    describe2("Connection State", () => {
-      test2("isConnected should be false before connection opens", async (c) => {
+    describe3("Connection State", () => {
+      test3("isConnected should be false before connection opens", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-isconnected-initial"
         ]);
         const connection = handle.connect();
-        expect2(connection.isConnected).toBe(false);
+        expect3(connection.isConnected).toBe(false);
         await vi2.waitFor(() => {
-          expect2(connection.isConnected).toBe(true);
+          expect3(connection.isConnected).toBe(true);
         });
         await connection.dispose();
       });
-      test2("onOpen should be called when connection opens", async (c) => {
+      test3("onOpen should be called when connection opens", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-onopen"]);
         const connection = handle.connect();
@@ -623,12 +817,12 @@ function runActorConnTests(driverTestConfig) {
           openCount++;
         });
         await vi2.waitFor(() => {
-          expect2(openCount).toBe(1);
+          expect3(openCount).toBe(1);
         });
-        expect2(connection.isConnected).toBe(true);
+        expect3(connection.isConnected).toBe(true);
         await connection.dispose();
       });
-      test2("onClose should be called when connection closes via dispose", async (c) => {
+      test3("onClose should be called when connection closes via dispose", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-onclose"]);
         const connection = handle.connect();
@@ -637,13 +831,13 @@ function runActorConnTests(driverTestConfig) {
           closeCount++;
         });
         await vi2.waitFor(() => {
-          expect2(connection.isConnected).toBe(true);
+          expect3(connection.isConnected).toBe(true);
         });
         await connection.dispose();
-        expect2(closeCount).toBe(1);
-        expect2(connection.isConnected).toBe(false);
+        expect3(closeCount).toBe(1);
+        expect3(connection.isConnected).toBe(false);
       });
-      test2("should be able to unsubscribe from onOpen", async (c) => {
+      test3("should be able to unsubscribe from onOpen", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-onopen-unsub"
@@ -655,12 +849,12 @@ function runActorConnTests(driverTestConfig) {
         });
         unsubscribe();
         await vi2.waitFor(() => {
-          expect2(connection.isConnected).toBe(true);
+          expect3(connection.isConnected).toBe(true);
         });
-        expect2(openCount).toBe(0);
+        expect3(openCount).toBe(0);
         await connection.dispose();
       });
-      test2("should be able to unsubscribe from onClose", async (c) => {
+      test3("should be able to unsubscribe from onClose", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-onclose-unsub"
@@ -671,13 +865,13 @@ function runActorConnTests(driverTestConfig) {
           closeCount++;
         });
         await vi2.waitFor(() => {
-          expect2(connection.isConnected).toBe(true);
+          expect3(connection.isConnected).toBe(true);
         });
         unsubscribe();
         await connection.dispose();
-        expect2(closeCount).toBe(0);
+        expect3(closeCount).toBe(0);
       });
-      test2("multiple onOpen handlers should all be called", async (c) => {
+      test3("multiple onOpen handlers should all be called", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-multi-onopen"
@@ -692,12 +886,12 @@ function runActorConnTests(driverTestConfig) {
           handler2Called = true;
         });
         await vi2.waitFor(() => {
-          expect2(handler1Called).toBe(true);
-          expect2(handler2Called).toBe(true);
+          expect3(handler1Called).toBe(true);
+          expect3(handler2Called).toBe(true);
         });
         await connection.dispose();
       });
-      test2("multiple onClose handlers should all be called", async (c) => {
+      test3("multiple onClose handlers should all be called", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-multi-onclose"
@@ -712,15 +906,15 @@ function runActorConnTests(driverTestConfig) {
           handler2Called = true;
         });
         await vi2.waitFor(() => {
-          expect2(connection.isConnected).toBe(true);
+          expect3(connection.isConnected).toBe(true);
         });
         await connection.dispose();
-        expect2(handler1Called).toBe(true);
-        expect2(handler2Called).toBe(true);
+        expect3(handler1Called).toBe(true);
+        expect3(handler2Called).toBe(true);
       });
     });
-    describe2("Large Payloads", () => {
-      test2("should handle large request within size limit", async (c) => {
+    describe3("Large Payloads", () => {
+      test3("should handle large request within size limit", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.largePayloadConnActor.getOrCreate([
           "test-large-request"
@@ -731,14 +925,14 @@ function runActorConnTests(driverTestConfig) {
           items.push(`Item ${i} with some additional text to increase size`);
         }
         const result = await connection.processLargeRequest({ items });
-        expect2(result.itemCount).toBe(800);
-        expect2(result.firstItem).toBe("Item 0 with some additional text to increase size");
-        expect2(result.lastItem).toBe("Item 799 with some additional text to increase size");
+        expect3(result.itemCount).toBe(800);
+        expect3(result.firstItem).toBe("Item 0 with some additional text to increase size");
+        expect3(result.lastItem).toBe("Item 799 with some additional text to increase size");
         const lastRequestSize = await connection.getLastRequestSize();
-        expect2(lastRequestSize).toBe(800);
+        expect3(lastRequestSize).toBe(800);
         await connection.dispose();
       });
-      test2("should reject request exceeding maxIncomingMessageSize", async (c) => {
+      test3("should reject request exceeding maxIncomingMessageSize", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.largePayloadConnActor.getOrCreate([
           "test-large-request-exceed"
@@ -748,30 +942,30 @@ function runActorConnTests(driverTestConfig) {
         for (let i = 0; i < 1500; i++) {
           items.push(`Item ${i} with some additional text to increase size`);
         }
-        await expect2(
+        await expect3(
           connection.processLargeRequest({ items })
         ).rejects.toThrow();
         await connection.dispose();
       });
-      test2("should handle large response", async (c) => {
+      test3("should handle large response", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.largePayloadConnActor.getOrCreate([
           "test-large-response"
         ]);
         const connection = handle.connect();
         const result = await connection.getLargeResponse(800);
-        expect2(result.items).toHaveLength(800);
-        expect2(result.items[0]).toBe("Item 0 with some additional text to increase size");
-        expect2(result.items[799]).toBe("Item 799 with some additional text to increase size");
+        expect3(result.items).toHaveLength(800);
+        expect3(result.items[0]).toBe("Item 0 with some additional text to increase size");
+        expect3(result.items[799]).toBe("Item 799 with some additional text to increase size");
         await connection.dispose();
       });
-      test2("should reject response exceeding maxOutgoingMessageSize", async (c) => {
+      test3("should reject response exceeding maxOutgoingMessageSize", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.largePayloadConnActor.getOrCreate([
           "test-large-response-exceed"
         ]);
         const connection = handle.connect();
-        await expect2(
+        await expect3(
           connection.getLargeResponse(2e4)
         ).rejects.toThrow();
         await connection.dispose();
@@ -781,60 +975,60 @@ function runActorConnTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-conn-hibernation.ts
-import { describe as describe3, expect as expect3, test as test3, vi as vi3 } from "vitest";
+import { describe as describe4, expect as expect4, test as test4, vi as vi3 } from "vitest";
 function runActorConnHibernationTests(driverTestConfig) {
   var _a;
-  describe3.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
+  describe4.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
     "Connection Hibernation",
     () => {
-      test3("basic conn hibernation", async (c) => {
+      test4("basic conn hibernation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const hibernatingActor = client.hibernationActor.getOrCreate().connect();
         const ping1 = await hibernatingActor.ping();
-        expect3(ping1).toBe("pong");
+        expect4(ping1).toBe("pong");
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
           HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
-        expect3(ping2).toBe("pong");
+        expect4(ping2).toBe("pong");
         await hibernatingActor.dispose();
       });
-      test3("conn state persists through hibernation", async (c) => {
+      test4("conn state persists through hibernation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const hibernatingActor = client.hibernationActor.getOrCreate().connect();
         const count1 = await hibernatingActor.connIncrement();
-        expect3(count1).toBe(1);
+        expect4(count1).toBe(1);
         const count2 = await hibernatingActor.connIncrement();
-        expect3(count2).toBe(2);
+        expect4(count2).toBe(2);
         const initialLifecycle = await hibernatingActor.getConnLifecycleCounts();
-        expect3(initialLifecycle.connectCount).toBe(1);
-        expect3(initialLifecycle.disconnectCount).toBe(0);
+        expect4(initialLifecycle.connectCount).toBe(1);
+        expect4(initialLifecycle.disconnectCount).toBe(0);
         const initialActorCounts = await hibernatingActor.getActorCounts();
-        expect3(initialActorCounts.wakeCount).toBe(1);
-        expect3(initialActorCounts.sleepCount).toBe(0);
+        expect4(initialActorCounts.wakeCount).toBe(1);
+        expect4(initialActorCounts.sleepCount).toBe(0);
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
           HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
-        expect3(count3).toBe(2);
+        expect4(count3).toBe(2);
         const finalLifecycle = await hibernatingActor.getConnLifecycleCounts();
-        expect3(finalLifecycle.connectCount).toBe(1);
-        expect3(finalLifecycle.disconnectCount).toBe(0);
+        expect4(finalLifecycle.connectCount).toBe(1);
+        expect4(finalLifecycle.disconnectCount).toBe(0);
         const finalActorCounts = await hibernatingActor.getActorCounts();
-        expect3(finalActorCounts.wakeCount).toBe(2);
-        expect3(finalActorCounts.sleepCount).toBe(1);
+        expect4(finalActorCounts.wakeCount).toBe(2);
+        expect4(finalActorCounts.sleepCount).toBe(1);
         await hibernatingActor.dispose();
       });
-      test3("closing connection during hibernation", async (c) => {
+      test4("closing connection during hibernation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn1 = client.hibernationActor.getOrCreate().connect();
         await conn1.ping();
         const connectionIds = await conn1.getConnectionIds();
-        expect3(connectionIds.length).toBe(1);
+        expect4(connectionIds.length).toBe(1);
         const conn1Id = connectionIds[0];
         await conn1.triggerSleep();
         await waitFor(
@@ -847,8 +1041,8 @@ function runActorConnHibernationTests(driverTestConfig) {
         await vi3.waitFor(
           async () => {
             const newConnectionIds = await conn2.getConnectionIds();
-            expect3(newConnectionIds.length).toBe(1);
-            expect3(newConnectionIds[0]).not.toBe(conn1Id);
+            expect4(newConnectionIds.length).toBe(1);
+            expect4(newConnectionIds[0]).not.toBe(conn1Id);
           },
           {
             timeout: 5e3,
@@ -856,7 +1050,7 @@ function runActorConnHibernationTests(driverTestConfig) {
           }
         );
         const lifecycle = await conn2.getConnLifecycleCounts();
-        expect3(lifecycle.disconnectCount).toBe(0);
+        expect4(lifecycle.disconnectCount).toBe(0);
         await conn2.dispose();
       });
     }
@@ -864,22 +1058,22 @@ function runActorConnHibernationTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-conn-state.ts
-import { describe as describe4, expect as expect4, test as test4, vi as vi4 } from "vitest";
+import { describe as describe5, expect as expect5, test as test5, vi as vi4 } from "vitest";
 function runActorConnStateTests(driverTestConfig) {
-  describe4("Actor Connection State Tests", () => {
-    describe4("Connection State Initialization", () => {
-      test4("should retrieve connection state", async (c) => {
+  describe5("Actor Connection State Tests", () => {
+    describe5("Connection State Initialization", () => {
+      test5("should retrieve connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connection = client.connStateActor.getOrCreate().connect();
         const connState = await connection.getConnectionState();
-        expect4(connState.id).toBeDefined();
-        expect4(connState.username).toBeDefined();
-        expect4(connState.role).toBeDefined();
-        expect4(connState.counter).toBeDefined();
-        expect4(connState.createdAt).toBeDefined();
+        expect5(connState.id).toBeDefined();
+        expect5(connState.username).toBeDefined();
+        expect5(connState.role).toBeDefined();
+        expect5(connState.counter).toBeDefined();
+        expect5(connState.createdAt).toBeDefined();
         await connection.dispose();
       });
-      test4("should initialize connection state with custom parameters", async (c) => {
+      test5("should initialize connection state with custom parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connection = client.connStateActor.getOrCreate([], {
           params: {
@@ -888,13 +1082,13 @@ function runActorConnStateTests(driverTestConfig) {
           }
         }).connect();
         const connState = await connection.getConnectionState();
-        expect4(connState.username).toBe("testuser");
-        expect4(connState.role).toBe("admin");
+        expect5(connState.username).toBe("testuser");
+        expect5(connState.role).toBe("admin");
         await connection.dispose();
       });
     });
-    describe4("Connection State Management", () => {
-      test4("should maintain unique state for each connection", async (c) => {
+    describe5("Connection State Management", () => {
+      test5("should maintain unique state for each connection", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn1 = client.connStateActor.getOrCreate([], {
           params: { username: "user1" }
@@ -906,14 +1100,14 @@ function runActorConnStateTests(driverTestConfig) {
         await conn2.incrementConnCounter(10);
         const state1 = await conn1.getConnectionState();
         const state2 = await conn2.getConnectionState();
-        expect4(state1.counter).toBe(5);
-        expect4(state2.counter).toBe(10);
-        expect4(state1.username).toBe("user1");
-        expect4(state2.username).toBe("user2");
+        expect5(state1.counter).toBe(5);
+        expect5(state2.counter).toBe(10);
+        expect5(state1.username).toBe("user1");
+        expect5(state2.username).toBe("user2");
         await conn1.dispose();
         await conn2.dispose();
       });
-      test4("should track connections in shared state", async (c) => {
+      test5("should track connections in shared state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -922,12 +1116,12 @@ function runActorConnStateTests(driverTestConfig) {
         await conn2.getConnectionState();
         const state1 = await conn1.getConnectionState();
         const connectionIds = await conn1.getConnectionIds();
-        expect4(connectionIds.length).toBeGreaterThanOrEqual(2);
-        expect4(connectionIds).toContain(state1.id);
+        expect5(connectionIds.length).toBeGreaterThanOrEqual(2);
+        expect5(connectionIds).toContain(state1.id);
         await conn1.dispose();
         await conn2.dispose();
       });
-      test4("should identify different connections in the same actor", async (c) => {
+      test5("should identify different connections in the same actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -935,16 +1129,16 @@ function runActorConnStateTests(driverTestConfig) {
         await conn1.getConnectionState();
         await conn2.getConnectionState();
         const allStates = await conn1.getAllConnectionStates();
-        expect4(allStates.length).toBeGreaterThanOrEqual(2);
+        expect5(allStates.length).toBeGreaterThanOrEqual(2);
         const ids = allStates.map((state) => state.id);
         const uniqueIds = [...new Set(ids)];
-        expect4(uniqueIds.length).toBe(ids.length);
+        expect5(uniqueIds.length).toBe(ids.length);
         await conn1.dispose();
         await conn2.dispose();
       });
     });
-    describe4("Connection Lifecycle", () => {
-      test4("should track connection and disconnection events", async (c) => {
+    describe5("Connection Lifecycle", () => {
+      test5("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const debugHandle = client.connStateActor.getOrCreate(
           void 0,
@@ -956,11 +1150,11 @@ function runActorConnStateTests(driverTestConfig) {
         const connState = await conn.getConnectionState();
         await vi4.waitFor(async () => {
           const connectionIds = await debugHandle.getConnectionIds();
-          expect4(connectionIds).toContain(connState.id);
+          expect5(connectionIds).toContain(connState.id);
         });
         await vi4.waitFor(async () => {
           const disconnects = await debugHandle.getDisconnectionCount();
-          expect4(disconnects).toBe(0);
+          expect5(disconnects).toBe(0);
         });
         await conn.dispose();
         await vi4.waitFor(
@@ -968,7 +1162,7 @@ function runActorConnStateTests(driverTestConfig) {
             console.log("disconnects before");
             const disconnects = await debugHandle.getDisconnectionCount();
             console.log("disconnects", disconnects);
-            expect4(disconnects).toBe(1);
+            expect5(disconnects).toBe(1);
           },
           // SSE takes a long time to disconnect on CF Workers
           {
@@ -980,7 +1174,7 @@ function runActorConnStateTests(driverTestConfig) {
         await vi4.waitFor(async () => {
           const connectionIds = await debugHandle.getConnectionIds();
           console.log("conn ids", connectionIds);
-          expect4(connectionIds.length).toBe(1);
+          expect5(connectionIds.length).toBe(1);
         });
         await newConn.dispose();
         await vi4.waitFor(
@@ -988,7 +1182,7 @@ function runActorConnStateTests(driverTestConfig) {
             console.log("A");
             const disconnects = await debugHandle.getDisconnectionCount();
             console.log(`B ${disconnects}`);
-            expect4(disconnects).toBe(2);
+            expect5(disconnects).toBe(2);
           },
           // SSE takes a long time to disconnect on CF Workers
           {
@@ -997,25 +1191,25 @@ function runActorConnStateTests(driverTestConfig) {
           }
         );
       });
-      test4("should update connection state", async (c) => {
+      test5("should update connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn = client.connStateActor.getOrCreate().connect();
         const initialState = await conn.getConnectionState();
-        expect4(initialState.username).toBe("anonymous");
+        expect5(initialState.username).toBe("anonymous");
         const updatedState = await conn.updateConnection({
           username: "newname",
           role: "moderator"
         });
-        expect4(updatedState.username).toBe("newname");
-        expect4(updatedState.role).toBe("moderator");
+        expect5(updatedState.username).toBe("newname");
+        expect5(updatedState.role).toBe("moderator");
         const latestState = await conn.getConnectionState();
-        expect4(latestState.username).toBe("newname");
-        expect4(latestState.role).toBe("moderator");
+        expect5(latestState.username).toBe("newname");
+        expect5(latestState.role).toBe("moderator");
         await conn.dispose();
       });
     });
-    describe4("Connection Communication", () => {
-      test4("should send messages to specific connections", async (c) => {
+    describe5("Connection Communication", () => {
+      test5("should send messages to specific connections", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -1031,10 +1225,10 @@ function runActorConnStateTests(driverTestConfig) {
             state2.id,
             "Hello from conn1"
           );
-          expect4(success).toBe(true);
-          expect4(receivedMessages.length).toBe(1);
-          expect4(receivedMessages[0].from).toBe(state1.id);
-          expect4(receivedMessages[0].message).toBe(
+          expect5(success).toBe(true);
+          expect5(receivedMessages.length).toBe(1);
+          expect5(receivedMessages[0].from).toBe(state1.id);
+          expect5(receivedMessages[0].message).toBe(
             "Hello from conn1"
           );
         });
@@ -1045,11 +1239,334 @@ function runActorConnStateTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-db.ts
+import { describe as describe6, expect as expect6, test as test6 } from "vitest";
+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) {
+    describe6(`Actor Database (${variant}) Tests`, () => {
+      test6("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();
+        expect6(count).toBe(0);
+      });
+      test6("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();
+        expect6(values).toHaveLength(2);
+        expect6(values[0].value).toBe("alpha");
+        expect6(values[1].value).toBe("beta");
+        await actor.updateValue(first.id, "alpha-updated");
+        const updated = await actor.getValue(first.id);
+        expect6(updated).toBe("alpha-updated");
+        await actor.deleteValue(second.id);
+        const count = await actor.getCount();
+        expect6(count).toBe(1);
+        const rawCount = await actor.rawSelectCount();
+        expect6(rawCount).toBe(1);
+        const multiValue = await actor.multiStatementInsert("gamma");
+        expect6(multiValue).toBe("gamma-updated");
+      });
+      test6("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");
+        expect6(await actor.getCount()).toBe(1);
+        await actor.transactionRollback("rollback");
+        expect6(await actor.getCount()).toBe(1);
+      });
+      test6("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");
+        expect6(await actor.getCount()).toBe(1);
+        for (let i = 0; i < 3; i++) {
+          await actor.triggerSleep();
+          await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+          expect6(await actor.getCount()).toBe(1);
+        }
+      });
+      test6("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);
+        expect6(await actor.getDisconnectInsertCount()).toBe(1);
+      });
+      test6("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);
+        expect6(await actor.getCount()).toBe(HIGH_VOLUME_COUNT);
+      });
+      test6("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);
+          expect6(storedSize).toBe(size);
+        }
+      });
+      test6("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);
+        expect6(storedSize).toBe(LARGE_PAYLOAD_SIZE);
+      });
+      test6("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();
+        expect6(grownPages).toBeGreaterThanOrEqual(baselinePages);
+        expect6(shrunkPages).toBeLessThanOrEqual(grownPages);
+        expect6(regrownPages).toBeGreaterThan(shrunkPages);
+      });
+      test6("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);
+        expect6(result.value).toBe("Updated 49");
+        const value = await actor.getValue(id);
+        expect6(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
+        );
+        expect6(updatedRows).toHaveLength(HOT_ROW_COUNT);
+        for (const row of updatedRows) {
+          expect6(row.value).toMatch(/^v-\d+$/);
+        }
+      });
+      test6("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
+        );
+        expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+        await actor.triggerSleep();
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+        expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+      });
+    });
+  }
+  describe6("Actor Database Lifecycle Cleanup Tests", () => {
+    test6("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);
+      }
+      expect6(after.create).toBeGreaterThanOrEqual(before.create);
+      expect6(after.migrate).toBeGreaterThanOrEqual(before.migrate);
+      expect6(after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+    });
+    test6("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);
+      }
+      expect6(cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
+    });
+    test6("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 {
+        threw = true;
+      }
+      expect6(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);
+      }
+      expect6(cleanupCount).toBeGreaterThanOrEqual(1);
+    });
+    test6("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) {
+        expect6(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) {
+        expect6(lifecycleCleanup.get(actorId) ?? 0).toBeGreaterThanOrEqual(1);
+      }
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-destroy.ts
-import { describe as describe5, expect as expect5, test as test5, vi as vi5 } from "vitest";
+import { describe as describe7, expect as expect7, test as test7, vi as vi5 } from "vitest";
 function runActorDestroyTests(driverTestConfig) {
-  describe5("Actor Destroy Tests", () => {
-    test5("actor destroy clears state (without connect)", async (c) => {
+  describe7("Actor Destroy Tests", () => {
+    test7("actor destroy clears state (without connect)", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actorKey = "test-destroy-without-connect";
       const observer = client.destroyObserver.getOrCreate(["observer"]);
@@ -1057,12 +1574,12 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = client.destroyActor.getOrCreate([actorKey]);
       await destroyActor.setValue(42);
       const value = await destroyActor.getValue();
-      expect5(value).toBe(42);
+      expect7(value).toBe(42);
       const actorId = await destroyActor.resolve();
       await destroyActor.destroy();
       await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect7(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
       await vi5.waitFor(async () => {
         let actorRunning = false;
@@ -1070,20 +1587,20 @@ function runActorDestroyTests(driverTestConfig) {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect5(err.group).toBe("actor");
-          expect5(err.code).toBe("not_found");
+          expect7(err.group).toBe("actor");
+          expect7(err.code).toBe("not_found");
         }
-        expect5(actorRunning, "actor still running").toBeFalsy();
+        expect7(actorRunning, "actor still running").toBeFalsy();
       });
       let existsById = false;
       try {
         await client.destroyActor.getForId(actorId).getValue();
         existsById = true;
       } catch (err) {
-        expect5(err.group).toBe("actor");
-        expect5(err.code).toBe("not_found");
+        expect7(err.group).toBe("actor");
+        expect7(err.code).toBe("not_found");
       }
-      expect5(
+      expect7(
         existsById,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1092,10 +1609,10 @@ function runActorDestroyTests(driverTestConfig) {
         await client.destroyActor.get(["test-destroy-without-connect"]).resolve();
         existsByKey = true;
       } catch (err) {
-        expect5(err.group).toBe("actor");
-        expect5(err.code).toBe("not_found");
+        expect7(err.group).toBe("actor");
+        expect7(err.code).toBe("not_found");
       }
-      expect5(
+      expect7(
         existsByKey,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1103,9 +1620,9 @@ function runActorDestroyTests(driverTestConfig) {
         "test-destroy-without-connect"
       ]);
       const newValue = await newActor.getValue();
-      expect5(newValue).toBe(0);
+      expect7(newValue).toBe(0);
     });
-    test5("actor destroy clears state (with connect)", async (c) => {
+    test7("actor destroy clears state (with connect)", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actorKey = "test-destroy-with-connect";
       const observer = client.destroyObserver.getOrCreate(["observer"]);
@@ -1117,12 +1634,12 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = destroyActorHandle.connect();
       await destroyActor.setValue(99);
       const value = await destroyActor.getValue();
-      expect5(value).toBe(99);
+      expect7(value).toBe(99);
       await destroyActor.destroy();
       await destroyActor.dispose();
       await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect7(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
       await vi5.waitFor(async () => {
         let actorRunning = false;
@@ -1130,20 +1647,20 @@ function runActorDestroyTests(driverTestConfig) {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect5(err.group).toBe("actor");
-          expect5(err.code).toBe("not_found");
+          expect7(err.group).toBe("actor");
+          expect7(err.code).toBe("not_found");
         }
-        expect5(actorRunning, "actor still running").toBeFalsy();
+        expect7(actorRunning, "actor still running").toBeFalsy();
       });
       let existsById = false;
       try {
         await client.destroyActor.getForId(actorId).getValue();
         existsById = true;
       } catch (err) {
-        expect5(err.group).toBe("actor");
-        expect5(err.code).toBe("not_found");
+        expect7(err.group).toBe("actor");
+        expect7(err.code).toBe("not_found");
       }
-      expect5(
+      expect7(
         existsById,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1152,10 +1669,10 @@ function runActorDestroyTests(driverTestConfig) {
         await client.destroyActor.get(["test-destroy-with-connect"]).resolve();
         existsByKey = true;
       } catch (err) {
-        expect5(err.group).toBe("actor");
-        expect5(err.code).toBe("not_found");
+        expect7(err.group).toBe("actor");
+        expect7(err.code).toBe("not_found");
       }
-      expect5(
+      expect7(
         existsByKey,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1163,9 +1680,9 @@ function runActorDestroyTests(driverTestConfig) {
         "test-destroy-with-connect"
       ]);
       const newValue = await newActor.getValue();
-      expect5(newValue).toBe(0);
+      expect7(newValue).toBe(0);
     });
-    test5("actor destroy allows recreation via getOrCreate with resolve", async (c) => {
+    test7("actor destroy allows recreation via getOrCreate with resolve", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actorKey = "test-destroy-getorcreate-resolve";
       const observer = client.destroyObserver.getOrCreate(["observer"]);
@@ -1173,12 +1690,12 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = client.destroyActor.getOrCreate([actorKey]);
       await destroyActor.setValue(123);
       const value = await destroyActor.getValue();
-      expect5(value).toBe(123);
+      expect7(value).toBe(123);
       const actorId = await destroyActor.resolve();
       await destroyActor.destroy();
       await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect7(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
       await vi5.waitFor(async () => {
         let actorRunning = false;
@@ -1186,17 +1703,17 @@ function runActorDestroyTests(driverTestConfig) {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect5(err.group).toBe("actor");
-          expect5(err.code).toBe("not_found");
+          expect7(err.group).toBe("actor");
+          expect7(err.code).toBe("not_found");
         }
-        expect5(actorRunning, "actor still running").toBeFalsy();
+        expect7(actorRunning, "actor still running").toBeFalsy();
       });
       const newHandle = client.destroyActor.getOrCreate([actorKey]);
       const newActorId = await newHandle.resolve();
       const newValue = await newHandle.getValue();
-      expect5(newValue).toBe(0);
+      expect7(newValue).toBe(0);
     });
-    test5("actor destroy allows recreation via create", async (c) => {
+    test7("actor destroy allows recreation via create", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actorKey = "test-destroy-create";
       const observer = client.destroyObserver.getOrCreate(["observer"]);
@@ -1204,12 +1721,12 @@ function runActorDestroyTests(driverTestConfig) {
       const initialHandle = await client.destroyActor.create([actorKey]);
       await initialHandle.setValue(456);
       const value = await initialHandle.getValue();
-      expect5(value).toBe(456);
+      expect7(value).toBe(456);
       const actorId = await initialHandle.resolve();
       await initialHandle.destroy();
       await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect7(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
       await vi5.waitFor(async () => {
         let actorRunning = false;
@@ -1217,31 +1734,31 @@ function runActorDestroyTests(driverTestConfig) {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect5(err.group).toBe("actor");
-          expect5(err.code).toBe("not_found");
+          expect7(err.group).toBe("actor");
+          expect7(err.code).toBe("not_found");
         }
-        expect5(actorRunning, "actor still running").toBeFalsy();
+        expect7(actorRunning, "actor still running").toBeFalsy();
       });
       const newHandle = await client.destroyActor.create([actorKey]);
       const newActorId = await newHandle.resolve();
       const newValue = await newHandle.getValue();
-      expect5(newValue).toBe(0);
+      expect7(newValue).toBe(0);
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-driver.ts
-import { describe as describe9 } from "vitest";
+import { describe as describe11 } from "vitest";
 
 // src/driver-test-suite/tests/actor-schedule.ts
-import { describe as describe6, expect as expect6, test as test6 } from "vitest";
+import { describe as describe8, expect as expect8, test as test8 } from "vitest";
 function runActorScheduleTests(driverTestConfig) {
   var _a;
-  describe6.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+  describe8.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
     "Actor Schedule Tests",
     () => {
-      describe6("Scheduled Alarms", () => {
-        test6("executes c.schedule.at() with specific timestamp", async (c) => {
+      describe8("Scheduled Alarms", () => {
+        test8("executes c.schedule.at() with specific timestamp", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1252,10 +1769,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect6(lastRun).toBeGreaterThan(0);
-          expect6(scheduledCount).toBe(1);
+          expect8(lastRun).toBeGreaterThan(0);
+          expect8(scheduledCount).toBe(1);
         });
-        test6("executes c.schedule.after() with delay", async (c) => {
+        test8("executes c.schedule.after() with delay", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1265,10 +1782,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect6(lastRun).toBeGreaterThan(0);
-          expect6(scheduledCount).toBe(1);
+          expect8(lastRun).toBeGreaterThan(0);
+          expect8(scheduledCount).toBe(1);
         });
-        test6("multiple scheduled tasks execute in order", async (c) => {
+        test8("multiple scheduled tasks execute in order", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1280,13 +1797,16 @@ function runActorScheduleTests(driverTestConfig) {
           await scheduled.scheduleTaskAfterWithId("third", 1250);
           await waitFor(driverTestConfig, 500);
           const history1 = await scheduled.getTaskHistory();
-          expect6(history1).toEqual(["first"]);
+          expect8(history1[0]).toBe("first");
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          expect6(history2).toEqual(["first", "second"]);
+          expect8(history2.slice(0, 2)).toEqual([
+            "first",
+            "second"
+          ]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
-          expect6(history3).toEqual(["first", "second", "third"]);
+          expect8(history3).toEqual(["first", "second", "third"]);
         });
       });
     }
@@ -1294,33 +1814,33 @@ function runActorScheduleTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-sleep.ts
-import { describe as describe7, expect as expect7, test as test7 } from "vitest";
+import { describe as describe9, expect as expect9, test as test9 } from "vitest";
 function runActorSleepTests(driverTestConfig) {
   var _a;
-  describe7.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
-    test7("actor sleep persists state", async (c) => {
+  describe9.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    test9("actor sleep persists state", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await waitFor(driverTestConfig, 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("actor sleep persists state with connect", async (c) => {
+    test9("actor sleep persists state with connect", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate().connect();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
@@ -1328,108 +1848,108 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("actor automatically sleeps after timeout", async (c) => {
+    test9("actor automatically sleeps after timeout", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("actor automatically sleeps after timeout with connect", async (c) => {
+    test9("actor automatically sleeps after timeout with connect", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate().connect();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("rpc calls keep actor awake", async (c) => {
+    test9("rpc calls keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("alarms keep actor awake", async (c) => {
+    test9("alarms keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT - 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
     });
-    test7("alarms wake actors", async (c) => {
+    test9("alarms wake actors", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT + 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("long running rpcs keep actor awake", async (c) => {
+    test9("long running rpcs keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleepWithLongRpc.getOrCreate().connect();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       const waitPromise = new Promise(
         (resolve) => sleepActor.once("waiting", resolve)
@@ -1441,19 +1961,19 @@ function runActorSleepTests(driverTestConfig) {
       await longRunningPromise;
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("active raw websockets keep actor awake", async (c) => {
+    test9("active raw websockets keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1461,10 +1981,10 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
-      const ws = await sleepActor.websocket();
+      const ws = await sleepActor.webSocket();
       await new Promise((resolve, reject) => {
         ws.onopen = () => resolve();
         ws.onerror = reject;
@@ -1487,17 +2007,17 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      expect7(counts.sleepCount).toBe(0);
-      expect7(counts.startCount).toBe(1);
+      expect9(counts.sleepCount).toBe(0);
+      expect9(counts.startCount).toBe(1);
       ws.close();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("active raw fetch requests keep actor awake", async (c) => {
+    test9("active raw fetch requests keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1505,8 +2025,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawHttp.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       const fetchDuration = SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
@@ -1514,67 +2034,67 @@ function runActorSleepTests(driverTestConfig) {
       );
       const response = await fetchPromise;
       const result = await response.json();
-      expect7(result.completed).toBe(true);
+      expect9(result.completed).toBe(true);
       {
         const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
-        expect7(requestCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
+        expect9(requestCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(1);
-        expect7(startCount).toBe(2);
+        expect9(sleepCount).toBe(1);
+        expect9(startCount).toBe(2);
       }
     });
-    test7("noSleep option disables sleeping", async (c) => {
+    test9("noSleep option disables sleeping", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect7(sleepCount).toBe(0);
-        expect7(startCount).toBe(1);
+        expect9(sleepCount).toBe(0);
+        expect9(startCount).toBe(1);
       }
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-state.ts
-import { describe as describe8, expect as expect8, test as test8 } from "vitest";
+import { describe as describe10, expect as expect10, test as test10 } from "vitest";
 function runActorStateTests(driverTestConfig) {
-  describe8("Actor State Tests", () => {
-    describe8("State Persistence", () => {
-      test8("persists state between actor instances", async (c) => {
+  describe10("Actor State Tests", () => {
+    describe10("State Persistence", () => {
+      test10("persists state between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterInstance = client.counter.getOrCreate();
         const initialCount = await counterInstance.increment(5);
-        expect8(initialCount).toBe(5);
+        expect10(initialCount).toBe(5);
         const sameInstance = client.counter.getOrCreate();
         const persistedCount = await sameInstance.increment(3);
-        expect8(persistedCount).toBe(8);
+        expect10(persistedCount).toBe(8);
       });
-      test8("restores state after actor disconnect/reconnect", async (c) => {
+      test10("restores state after actor disconnect/reconnect", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterInstance = client.counter.getOrCreate();
         await counterInstance.increment(5);
         const reconnectedInstance = client.counter.getOrCreate();
         const persistedCount = await reconnectedInstance.increment(0);
-        expect8(persistedCount).toBe(5);
+        expect10(persistedCount).toBe(5);
       });
-      test8("maintains separate state for different actors", async (c) => {
+      test10("maintains separate state for different actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterA = client.counter.getOrCreate(["counter-a"]);
         await counterA.increment(5);
@@ -1582,8 +2102,8 @@ function runActorStateTests(driverTestConfig) {
         await counterB.increment(10);
         const countA = await counterA.increment(0);
         const countB = await counterB.increment(0);
-        expect8(countA).toBe(5);
-        expect8(countB).toBe(10);
+        expect10(countA).toBe(5);
+        expect10(countB).toBe(10);
       });
     });
   });
@@ -1591,7 +2111,7 @@ function runActorStateTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-driver.ts
 function runActorDriverTests(driverTestConfig) {
-  describe9("Actor Driver Tests", () => {
+  describe11("Actor Driver Tests", () => {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
     runActorSleepTests(driverTestConfig);
@@ -1599,82 +2119,82 @@ function runActorDriverTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-error-handling.ts
-import { describe as describe10, expect as expect9, test as test9 } from "vitest";
+import { describe as describe12, expect as expect11, test as test11 } from "vitest";
 function runActorErrorHandlingTests(driverTestConfig) {
-  describe10("Actor Error Handling Tests", () => {
-    describe10("UserError Handling", () => {
-      test9("should handle simple UserError with message", async (c) => {
+  describe12("Actor Error Handling Tests", () => {
+    describe12("UserError Handling", () => {
+      test11("should handle simple UserError with message", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwSimpleError();
-          expect9(true).toBe(false);
+          expect11(true).toBe(false);
         } catch (error) {
-          expect9(error.message).toBe("Simple error message");
-          expect9(error.code).toBe("user_error");
-          expect9(error.metadata).toBeUndefined();
+          expect11(error.message).toBe("Simple error message");
+          expect11(error.code).toBe("user_error");
+          expect11(error.metadata).toBeUndefined();
         }
       });
-      test9("should handle detailed UserError with code and metadata", async (c) => {
+      test11("should handle detailed UserError with code and metadata", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwDetailedError();
-          expect9(true).toBe(false);
+          expect11(true).toBe(false);
         } catch (error) {
-          expect9(error.message).toBe("Detailed error message");
-          expect9(error.code).toBe("detailed_error");
-          expect9(error.metadata).toBeDefined();
-          expect9(error.metadata.reason).toBe("test");
-          expect9(error.metadata.timestamp).toBeDefined();
+          expect11(error.message).toBe("Detailed error message");
+          expect11(error.code).toBe("detailed_error");
+          expect11(error.metadata).toBeDefined();
+          expect11(error.metadata.reason).toBe("test");
+          expect11(error.metadata.timestamp).toBeDefined();
         }
       });
     });
-    describe10("Internal Error Handling", () => {
-      test9("should convert internal errors to safe format", async (c) => {
+    describe12("Internal Error Handling", () => {
+      test11("should convert internal errors to safe format", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwInternalError();
-          expect9(true).toBe(false);
+          expect11(true).toBe(false);
         } catch (error) {
-          expect9(error.code).toBe(INTERNAL_ERROR_CODE);
-          expect9(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+          expect11(error.code).toBe(INTERNAL_ERROR_CODE);
+          expect11(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
-    describe10.skip("Action Timeout", () => {
-      test9("should handle action timeouts with custom duration", async (c) => {
+    describe12.skip("Action Timeout", () => {
+      test11("should handle action timeouts with custom duration", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         const timeoutPromise = handle.timeoutAction();
         try {
           await timeoutPromise;
-          expect9(true).toBe(false);
+          expect11(true).toBe(false);
         } catch (error) {
-          expect9(error.message).toMatch(/timed out/i);
+          expect11(error.message).toMatch(/timed out/i);
         }
       });
-      test9("should successfully run actions within timeout", async (c) => {
+      test11("should successfully run actions within timeout", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         const result = await handle.delayedAction(200);
-        expect9(result).toBe("Completed after 200ms");
+        expect11(result).toBe("Completed after 200ms");
       });
-      test9("should respect different timeouts for different actors", async (c) => {
+      test11("should respect different timeouts for different actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         try {
           await client.customTimeoutActor.getOrCreate().slowAction();
-          expect9(true).toBe(false);
+          expect11(true).toBe(false);
         } catch (error) {
-          expect9(error.message).toMatch(/timed out/i);
+          expect11(error.message).toMatch(/timed out/i);
         }
         const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
-        expect9(quickResult).toBe("Quick action completed");
+        expect11(quickResult).toBe("Quick action completed");
       });
     });
-    describe10("Error Recovery", () => {
-      test9("should continue working after errors", async (c) => {
+    describe12("Error Recovery", () => {
+      test11("should continue working after errors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
@@ -1682,27 +2202,27 @@ function runActorErrorHandlingTests(driverTestConfig) {
         } catch (error) {
         }
         const result = await handle.successfulAction();
-        expect9(result).toBe("success");
+        expect11(result).toBe("success");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-handle.ts
-import { describe as describe11, expect as expect10, test as test10 } from "vitest";
+import { describe as describe13, expect as expect12, test as test12 } from "vitest";
 function runActorHandleTests(driverTestConfig) {
-  describe11("Actor Handle Tests", () => {
-    describe11("Access Methods", () => {
-      test10("should use .get() to access a actor", async (c) => {
+  describe13("Actor Handle Tests", () => {
+    describe13("Access Methods", () => {
+      test12("should use .get() to access a actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         await client.counter.create(["test-get-handle"]);
         const handle = client.counter.get(["test-get-handle"]);
         const count = await handle.increment(5);
-        expect10(count).toBe(5);
+        expect12(count).toBe(5);
         const retrievedCount = await handle.getCount();
-        expect10(retrievedCount).toBe(5);
+        expect12(retrievedCount).toBe(5);
       });
-      test10("should use .getForId() to access a actor by ID", async (c) => {
+      test12("should use .getForId() to access a actor by ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-get-for-id-handle"
@@ -1711,73 +2231,73 @@ function runActorHandleTests(driverTestConfig) {
         const actorId = await handle.resolve();
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect10(count).toBe(3);
+        expect12(count).toBe(3);
         const newCount = await idHandle.increment(4);
-        expect10(newCount).toBe(7);
+        expect12(newCount).toBe(7);
       });
-      test10("should use .getOrCreate() to access or create a actor", async (c) => {
+      test12("should use .getOrCreate() to access or create a actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-get-or-create-handle"
         ]);
         const count = await handle.increment(7);
-        expect10(count).toBe(7);
+        expect12(count).toBe(7);
         const sameHandle = client.counter.getOrCreate([
           "test-get-or-create-handle"
         ]);
         const retrievedCount = await sameHandle.getCount();
-        expect10(retrievedCount).toBe(7);
+        expect12(retrievedCount).toBe(7);
       });
-      test10("should use (await create()) to create and return a handle", async (c) => {
+      test12("should use (await create()) to create and return a handle", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create([
           "test-create-handle"
         ]);
         const count = await handle.increment(9);
-        expect10(count).toBe(9);
+        expect12(count).toBe(9);
         const retrievedCount = await handle.getCount();
-        expect10(retrievedCount).toBe(9);
+        expect12(retrievedCount).toBe(9);
       });
-      test10("errors when calling create twice with the same key", async (c) => {
+      test12("errors when calling create twice with the same key", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const key = ["duplicate-create-handle", crypto.randomUUID()];
         await client.counter.create(key);
         try {
           await client.counter.create(key);
-          expect10.fail("did not error on duplicate create");
+          expect12.fail("did not error on duplicate create");
         } catch (err) {
-          expect10(err.group).toBe("actor");
-          expect10(err.code).toBe("duplicate_key");
+          expect12(err.group).toBe("actor");
+          expect12(err.code).toBe("duplicate_key");
         }
       });
-      test10(".get().resolve() errors for non-existent actor", async (c) => {
+      test12(".get().resolve() errors for non-existent actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const missingId = `nonexistent-${crypto.randomUUID()}`;
         try {
           await client.counter.get([missingId]).resolve();
-          expect10.fail(
+          expect12.fail(
             "did not error for get().resolve() on missing actor"
           );
         } catch (err) {
-          expect10(err.group).toBe("actor");
-          expect10(err.code).toBe("not_found");
+          expect12(err.group).toBe("actor");
+          expect12(err.code).toBe("not_found");
         }
       });
     });
-    describe11("Action Functionality", () => {
-      test10("should call actions directly on the handle", async (c) => {
+    describe13("Action Functionality", () => {
+      test12("should call actions directly on the handle", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate([
           "test-action-handle"
         ]);
         const count1 = await handle.increment(3);
-        expect10(count1).toBe(3);
+        expect12(count1).toBe(3);
         const count2 = await handle.increment(5);
-        expect10(count2).toBe(8);
+        expect12(count2).toBe(8);
         const retrievedCount = await handle.getCount();
-        expect10(retrievedCount).toBe(8);
+        expect12(retrievedCount).toBe(8);
       });
-      test10("should handle independent handles to the same actor", async (c) => {
+      test12("should handle independent handles to the same actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle1 = client.counter.getOrCreate([
           "test-multiple-handles"
@@ -1785,82 +2305,82 @@ function runActorHandleTests(driverTestConfig) {
         const handle2 = client.counter.get(["test-multiple-handles"]);
         await handle1.increment(3);
         const count = await handle2.getCount();
-        expect10(count).toBe(3);
+        expect12(count).toBe(3);
         const finalCount = await handle2.increment(4);
-        expect10(finalCount).toBe(7);
+        expect12(finalCount).toBe(7);
         const checkCount = await handle1.getCount();
-        expect10(checkCount).toBe(7);
+        expect12(checkCount).toBe(7);
       });
-      test10("should resolve a actor's ID", async (c) => {
+      test12("should resolve a actor's ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-resolve-id"]);
         await handle.increment(1);
         const actorId = await handle.resolve();
-        expect10(typeof actorId).toBe("string");
-        expect10(actorId).not.toBe("");
+        expect12(typeof actorId).toBe("string");
+        expect12(actorId).not.toBe("");
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect10(count).toBe(1);
+        expect12(count).toBe(1);
       });
     });
-    describe11("Lifecycle Hooks", () => {
-      test10("should trigger lifecycle hooks on actor creation", async (c) => {
+    describe13("Lifecycle Hooks", () => {
+      test12("should trigger lifecycle hooks on actor creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-handle"
         ]);
         const initialEvents = await handle.getEvents();
-        expect10(initialEvents).toContain("onWake");
+        expect12(initialEvents).toContain("onWake");
         const sameHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-handle"
         ]);
         const events = await sameHandle.getEvents();
-        expect10(events).toContain("onWake");
-        expect10(events.filter((e) => e === "onWake").length).toBe(1);
+        expect12(events).toContain("onWake");
+        expect12(events.filter((e) => e === "onWake").length).toBe(1);
       });
-      test10("should trigger lifecycle hooks for each Action call", async (c) => {
+      test12("should trigger lifecycle hooks for each Action call", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const viewHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-action"
         ]);
         const initialEvents = await viewHandle.getEvents();
-        expect10(initialEvents).toContain("onWake");
-        expect10(initialEvents).not.toContain("onBeforeConnect");
-        expect10(initialEvents).not.toContain("onConnect");
-        expect10(initialEvents).not.toContain("onDisconnect");
+        expect12(initialEvents).toContain("onWake");
+        expect12(initialEvents).not.toContain("onBeforeConnect");
+        expect12(initialEvents).not.toContain("onConnect");
+        expect12(initialEvents).not.toContain("onDisconnect");
         const trackingHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle-action"],
           { params: { trackLifecycle: true } }
         );
         await trackingHandle.increment(5);
         const eventsAfterAction = await viewHandle.getEvents();
-        expect10(eventsAfterAction).toContain("onBeforeConnect");
-        expect10(eventsAfterAction).toContain("onConnect");
-        expect10(eventsAfterAction).toContain("onDisconnect");
-        expect10(
+        expect12(eventsAfterAction).toContain("onBeforeConnect");
+        expect12(eventsAfterAction).toContain("onConnect");
+        expect12(eventsAfterAction).toContain("onDisconnect");
+        expect12(
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        expect10(
+        expect12(
           eventsAfterAction.filter((e) => e === "onConnect").length
         ).toBe(1);
-        expect10(
+        expect12(
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
-        expect10(
+        expect12(
           eventsAfterSecondAction.filter(
             (e) => e === "onBeforeConnect"
           ).length
         ).toBe(2);
-        expect10(
+        expect12(
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
         ).toBe(2);
-        expect10(
+        expect12(
           eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
         ).toBe(2);
       });
-      test10("should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
+      test12("should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const viewHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-multi-handle"
@@ -1876,12 +2396,12 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle1.increment(5);
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
-        expect10(events.filter((e) => e === "onWake").length).toBe(1);
-        expect10(
+        expect12(events.filter((e) => e === "onWake").length).toBe(1);
+        expect12(
           events.filter((e) => e === "onBeforeConnect").length
         ).toBe(2);
-        expect10(events.filter((e) => e === "onConnect").length).toBe(2);
-        expect10(events.filter((e) => e === "onDisconnect").length).toBe(
+        expect12(events.filter((e) => e === "onConnect").length).toBe(2);
+        expect12(events.filter((e) => e === "onDisconnect").length).toBe(
           2
         );
       });
@@ -1890,27 +2410,27 @@ function runActorHandleTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-inline-client.ts
-import { describe as describe12, expect as expect11, test as test11 } from "vitest";
+import { describe as describe14, expect as expect13, test as test13 } from "vitest";
 function runActorInlineClientTests(driverTestConfig) {
-  describe12("Actor Inline Client Tests", () => {
-    describe12("Stateless Client Calls", () => {
-      test11("should make stateless calls to other actors", async (c) => {
+  describe14("Actor Inline Client Tests", () => {
+    describe14("Stateless Client Calls", () => {
+      test13("should make stateless calls to other actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-test"]
         );
         const result = await inlineClientHandle.callCounterIncrement(5);
-        expect11(result).toBe(5);
+        expect13(result).toBe(5);
         const counterState = await inlineClientHandle.getCounterState();
-        expect11(counterState).toBe(5);
+        expect13(counterState).toBe(5);
         const messages = await inlineClientHandle.getMessages();
-        expect11(messages).toHaveLength(2);
-        expect11(messages[0]).toContain(
+        expect13(messages).toHaveLength(2);
+        expect13(messages[0]).toContain(
           "Called counter.increment(5), result: 5"
         );
-        expect11(messages[1]).toContain("Got counter state: 5");
+        expect13(messages[1]).toContain("Got counter state: 5");
       });
-      test11("should handle multiple stateless calls", async (c) => {
+      test13("should handle multiple stateless calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-multi"]
@@ -1919,58 +2439,58 @@ function runActorInlineClientTests(driverTestConfig) {
         const result1 = await inlineClientHandle.callCounterIncrement(3);
         const result2 = await inlineClientHandle.callCounterIncrement(7);
         const finalState = await inlineClientHandle.getCounterState();
-        expect11(result1).toBe(3);
-        expect11(result2).toBe(10);
-        expect11(finalState).toBe(10);
+        expect13(result1).toBe(3);
+        expect13(result2).toBe(10);
+        expect13(finalState).toBe(10);
         const messages = await inlineClientHandle.getMessages();
-        expect11(messages).toHaveLength(3);
-        expect11(messages[0]).toContain(
+        expect13(messages).toHaveLength(3);
+        expect13(messages[0]).toContain(
           "Called counter.increment(3), result: 3"
         );
-        expect11(messages[1]).toContain(
+        expect13(messages[1]).toContain(
           "Called counter.increment(7), result: 10"
         );
-        expect11(messages[2]).toContain("Got counter state: 10");
+        expect13(messages[2]).toContain("Got counter state: 10");
       });
     });
-    describe12("Stateful Client Calls", () => {
-      test11("should connect to other actors and receive events", async (c) => {
+    describe14("Stateful Client Calls", () => {
+      test13("should connect to other actors and receive events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-stateful"]
         );
         await inlineClientHandle.clearMessages();
         const result = await inlineClientHandle.connectToCounterAndIncrement(4);
-        expect11(result.result1).toBe(4);
-        expect11(result.result2).toBe(12);
-        expect11(result.events).toEqual([4, 12]);
+        expect13(result.result1).toBe(4);
+        expect13(result.result2).toBe(12);
+        expect13(result.events).toEqual([4, 12]);
         const messages = await inlineClientHandle.getMessages();
-        expect11(messages).toHaveLength(1);
-        expect11(messages[0]).toContain(
+        expect13(messages).toHaveLength(1);
+        expect13(messages[0]).toContain(
           "Connected to counter, incremented by 4 and 8"
         );
-        expect11(messages[0]).toContain("results: 4, 12");
-        expect11(messages[0]).toContain("events: [4,12]");
+        expect13(messages[0]).toContain("results: 4, 12");
+        expect13(messages[0]).toContain("events: [4,12]");
       });
-      test11("should handle stateful connection independently", async (c) => {
+      test13("should handle stateful connection independently", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-independent"]
         );
         await inlineClientHandle.clearMessages();
         const result = await inlineClientHandle.connectToCounterAndIncrement(2);
-        expect11(result.result1).toBe(2);
-        expect11(result.result2).toBe(6);
-        expect11(result.events).toEqual([2, 6]);
+        expect13(result.result1).toBe(2);
+        expect13(result.result2).toBe(6);
+        expect13(result.events).toEqual([2, 6]);
         const messages = await inlineClientHandle.getMessages();
-        expect11(messages).toHaveLength(1);
-        expect11(messages[0]).toContain(
+        expect13(messages).toHaveLength(1);
+        expect13(messages[0]).toContain(
           "Connected to counter, incremented by 2 and 4"
         );
       });
     });
-    describe12("Mixed Client Usage", () => {
-      test11("should handle both stateless and stateful calls", async (c) => {
+    describe14("Mixed Client Usage", () => {
+      test13("should handle both stateless and stateful calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-mixed"]
@@ -1978,17 +2498,17 @@ function runActorInlineClientTests(driverTestConfig) {
         await inlineClientHandle.clearMessages();
         await inlineClientHandle.callCounterIncrement(1);
         const statelessResult = await inlineClientHandle.getCounterState();
-        expect11(statelessResult).toBe(1);
+        expect13(statelessResult).toBe(1);
         const statefulResult = await inlineClientHandle.connectToCounterAndIncrement(3);
-        expect11(statefulResult.result1).toBe(3);
-        expect11(statefulResult.result2).toBe(9);
+        expect13(statefulResult.result1).toBe(3);
+        expect13(statefulResult.result2).toBe(9);
         const messages = await inlineClientHandle.getMessages();
-        expect11(messages).toHaveLength(3);
-        expect11(messages[0]).toContain(
+        expect13(messages).toHaveLength(3);
+        expect13(messages[0]).toContain(
           "Called counter.increment(1), result: 1"
         );
-        expect11(messages[1]).toContain("Got counter state: 1");
-        expect11(messages[2]).toContain(
+        expect13(messages[1]).toContain("Got counter state: 1");
+        expect13(messages[2]).toContain(
           "Connected to counter, incremented by 3 and 6"
         );
       });
@@ -1997,36 +2517,236 @@ function runActorInlineClientTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-inspector.ts
-import { describe as describe13 } from "vitest";
+import { describe as describe15, expect as expect14, test as test14 } from "vitest";
 function runActorInspectorTests(driverTestConfig) {
-  describe13.skip("Actor Inspector Tests", () => {
+  describe15("Actor Inspector HTTP API", () => {
+    test14("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" }
+      });
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toEqual({ state: { count: 5 } });
+    });
+    test14("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 } })
+        }
+      );
+      expect14(patchResponse.status).toBe(200);
+      const patchData = await patchResponse.json();
+      expect14(patchData).toEqual({ ok: true });
+      const count = await handle.getCount();
+      expect14(count).toBe(42);
+    });
+    test14("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" }
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toHaveProperty("connections");
+      expect14(Array.isArray(data.connections)).toBe(true);
+    });
+    test14("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" }
+      });
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toHaveProperty("rpcs");
+      expect14(data.rpcs).toContain("increment");
+      expect14(data.rpcs).toContain("getCount");
+      expect14(data.rpcs).toContain("setCount");
+    });
+    test14("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] })
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data.output).toBe(15);
+      const count = await handle.getCount();
+      expect14(count).toBe(15);
+    });
+    test14("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" }
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toHaveProperty("size");
+      expect14(data).toHaveProperty("maxSize");
+      expect14(data).toHaveProperty("truncated");
+      expect14(data).toHaveProperty("messages");
+      expect14(typeof data.size).toBe("number");
+      expect14(typeof data.maxSize).toBe("number");
+      expect14(typeof data.truncated).toBe("boolean");
+      expect14(Array.isArray(data.messages)).toBe(true);
+    });
+    test14("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" }
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toHaveProperty("otlp");
+      expect14(data).toHaveProperty("clamped");
+      expect14(typeof data.clamped).toBe("boolean");
+    });
+    test14("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" }
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data).toHaveProperty("history");
+      expect14(data).toHaveProperty("isWorkflowEnabled");
+      expect14(data.isWorkflowEnabled).toBe(false);
+      expect14(data.history).toBeNull();
+    });
+    test14("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" }
+        }
+      );
+      expect14(response.status).toBe(200);
+      const data = await response.json();
+      expect14(data.state).toEqual({ count: 7 });
+      expect14(Array.isArray(data.connections)).toBe(true);
+      expect14(data.rpcs).toContain("increment");
+      expect14(typeof data.queueSize).toBe("number");
+      expect14(data.isStateEnabled).toBe(true);
+      expect14(typeof data.isDatabaseEnabled).toBe("boolean");
+      expect14(data.isWorkflowEnabled).toBe(false);
+      expect14(data.workflowHistory).toBeNull();
+    });
+    test14("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" }
+      });
+      expect14(response.status).toBe(401);
+    });
   });
 }
 
 // src/driver-test-suite/tests/actor-kv.ts
-import { describe as describe14, expect as expect12, test as test12 } from "vitest";
+import { describe as describe16, expect as expect15, test as test15 } from "vitest";
 function runActorKvTests(driverTestConfig) {
-  describe14("Actor KV Tests", () => {
-    test12("supports text encoding and decoding", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
+  describe16("Actor KV Tests", () => {
+    test15("supports text encoding and decoding", async (c) => {
+      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");
-      expect12(value).toBe("hello");
+      expect15(value).toBe("hello");
       await kvHandle.putText("prefix-a", "alpha");
       await kvHandle.putText("prefix-b", "beta");
       const results = await kvHandle.listText("prefix-");
       const sorted = results.sort((a, b) => a.key.localeCompare(b.key));
-      expect12(sorted).toEqual([
+      expect15(sorted).toEqual([
         { key: "prefix-a", value: "alpha" },
         { key: "prefix-b", value: "beta" }
       ]);
     });
-    test12(
+    test15(
       "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,
@@ -2035,32 +2755,32 @@ function runActorKvTests(driverTestConfig) {
           23,
           42
         ]);
-        expect12(values).toEqual([4, 8, 15, 16, 23, 42]);
+        expect15(values).toEqual([4, 8, 15, 16, 23, 42]);
       }
     );
   });
 }
 
 // src/driver-test-suite/tests/actor-metadata.ts
-import { describe as describe15, expect as expect13, test as test13 } from "vitest";
+import { describe as describe17, expect as expect16, test as test16 } from "vitest";
 function runActorMetadataTests(driverTestConfig) {
-  describe15("Actor Metadata Tests", () => {
-    describe15("Actor Name", () => {
-      test13("should provide access to actor name", async (c) => {
+  describe17("Actor Metadata Tests", () => {
+    describe17("Actor Name", () => {
+      test16("should provide access to actor name", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         const actorName = await handle.getActorName();
-        expect13(actorName).toBe("metadataActor");
+        expect16(actorName).toBe("metadataActor");
       });
-      test13("should preserve actor name in state during onWake", async (c) => {
+      test16("should preserve actor name in state during onWake", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         const storedName = await handle.getStoredActorName();
-        expect13(storedName).toBe("metadataActor");
+        expect16(storedName).toBe("metadataActor");
       });
     });
-    describe15("Actor Tags", () => {
-      test13("should provide access to tags", async (c) => {
+    describe17("Actor Tags", () => {
+      test16("should provide access to tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2068,12 +2788,12 @@ function runActorMetadataTests(driverTestConfig) {
           purpose: "metadata-test"
         });
         const tags = await handle.getTags();
-        expect13(tags).toHaveProperty("env");
-        expect13(tags.env).toBe("test");
-        expect13(tags).toHaveProperty("purpose");
-        expect13(tags.purpose).toBe("metadata-test");
+        expect16(tags).toHaveProperty("env");
+        expect16(tags.env).toBe("test");
+        expect16(tags).toHaveProperty("purpose");
+        expect16(tags.purpose).toBe("metadata-test");
       });
-      test13("should allow accessing individual tags", async (c) => {
+      test16("should allow accessing individual tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2083,110 +2803,541 @@ function runActorMetadataTests(driverTestConfig) {
         const category = await handle.getTag("category");
         const version = await handle.getTag("version");
         const nonexistent = await handle.getTag("nonexistent");
-        expect13(category).toBe("test-actor");
-        expect13(version).toBe("1.0");
-        expect13(nonexistent).toBeNull();
+        expect16(category).toBe("test-actor");
+        expect16(version).toBe("1.0");
+        expect16(nonexistent).toBeNull();
       });
     });
-    describe15("Metadata Structure", () => {
-      test13("should provide complete metadata object", async (c) => {
+    describe17("Metadata Structure", () => {
+      test16("should provide complete metadata object", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({ type: "metadata-test" });
         await handle.setupTestRegion("us-west-1");
         const metadata = await handle.getMetadata();
-        expect13(metadata).toHaveProperty("name");
-        expect13(metadata.name).toBe("metadataActor");
-        expect13(metadata).toHaveProperty("tags");
-        expect13(metadata.tags).toHaveProperty("type");
-        expect13(metadata.tags.type).toBe("metadata-test");
-        expect13(metadata).toHaveProperty("region");
-        expect13(metadata.region).toBe("us-west-1");
+        expect16(metadata).toHaveProperty("name");
+        expect16(metadata.name).toBe("metadataActor");
+        expect16(metadata).toHaveProperty("tags");
+        expect16(metadata.tags).toHaveProperty("type");
+        expect16(metadata.tags.type).toBe("metadata-test");
+        expect16(metadata).toHaveProperty("region");
+        expect16(metadata.region).toBe("us-west-1");
       });
     });
-    describe15("Region Information", () => {
-      test13("should retrieve region information", async (c) => {
+    describe17("Region Information", () => {
+      test16("should retrieve region information", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestRegion("eu-central-1");
         const region = await handle.getRegion();
-        expect13(region).toBe("eu-central-1");
+        expect16(region).toBe("eu-central-1");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-onstatechange.ts
-import { describe as describe16, expect as expect14, test as test14 } from "vitest";
+import { describe as describe18, expect as expect17, test as test17 } from "vitest";
 function runActorOnStateChangeTests(driverTestConfig) {
-  describe16("Actor onStateChange Tests", () => {
-    test14("triggers onStateChange when state is modified", async (c) => {
+  describe18("Actor onStateChange Tests", () => {
+    test17("triggers onStateChange when state is modified", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.onStateChangeActor.getOrCreate();
       await actor.setValue(10);
       const changeCount = await actor.getChangeCount();
-      expect14(changeCount).toBe(1);
+      expect17(changeCount).toBe(1);
     });
-    test14("triggers onChange multiple times for multiple state changes", async (c) => {
+    test17("triggers onChange multiple times for multiple state changes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.onStateChangeActor.getOrCreate();
       await actor.incrementMultiple(3);
       const changeCount = await actor.getChangeCount();
-      expect14(changeCount).toBe(3);
+      expect17(changeCount).toBe(3);
     });
-    test14("does NOT trigger onChange for read-only actions", async (c) => {
+    test17("does NOT trigger onChange for read-only actions", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.onStateChangeActor.getOrCreate();
       await actor.setValue(5);
       const value = await actor.getValue();
-      expect14(value).toBe(5);
+      expect17(value).toBe(5);
       const changeCount = await actor.getChangeCount();
-      expect14(changeCount).toBe(1);
+      expect17(changeCount).toBe(1);
     });
-    test14("does NOT trigger onChange for computed values", async (c) => {
+    test17("does NOT trigger onChange for computed values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.onStateChangeActor.getOrCreate();
       await actor.setValue(3);
       {
         const changeCount = await actor.getChangeCount();
-        expect14(changeCount).toBe(1);
+        expect17(changeCount).toBe(1);
       }
       const doubled = await actor.getDoubled();
-      expect14(doubled).toBe(6);
+      expect17(doubled).toBe(6);
       {
         const changeCount = await actor.getChangeCount();
-        expect14(changeCount).toBe(1);
+        expect17(changeCount).toBe(1);
       }
     });
-    test14("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
+    test17("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.onStateChangeActor.getOrCreate();
       const connection = await actor.connect();
       const value = await connection.getValue();
-      expect14(value).toBe(0);
+      expect17(value).toBe(0);
       await connection.dispose();
       const changeCount = await actor.getChangeCount();
-      expect14(changeCount).toBe(0);
+      expect17(changeCount).toBe(0);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-queue.ts
+import { describe as describe19, expect as expect18, test as test18 } from "vitest";
+function runActorQueueTests(driverTestConfig) {
+  describe19("Actor Queue Tests", () => {
+    test18("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");
+      expect18(message).toEqual({
+        name: "greeting",
+        body: { hello: "world" }
+      });
+    });
+    test18("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");
+      expect18(message).toEqual({ name: "self", body: { value: 42 } });
+    });
+    test18("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 });
+      expect18(messages).toEqual([
+        { name: "a", body: 1 },
+        { name: "b", body: 2 }
+      ]);
+    });
+    test18("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
+      });
+      expect18(messages).toEqual([
+        { name: "one", body: "first" },
+        { name: "two", body: "second" }
+      ]);
+    });
+    test18("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 });
+      expect18(messages).toEqual([
+        { name: "one", body: "first" },
+        { name: "two", body: "second" }
+      ]);
+    });
+    test18("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;
+      expect18(messages).toEqual([]);
+    });
+    test18("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
+      });
+      expect18(messages).toEqual([]);
+    });
+    test18("abort throws ActorAborted", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.queueActor.getOrCreate(["abort-test"]);
+      try {
+        await handle.waitForAbort();
+        expect18.fail("expected ActorAborted error");
+      } catch (error) {
+        expect18(error.group).toBe("actor");
+        expect18(error.code).toBe("aborted");
+      }
+    });
+    test18("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();
+      expect18(result).toEqual({
+        group: "actor",
+        code: "aborted"
+      });
+    });
+    test18("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();
+      expect18(result).toEqual({
+        group: "actor",
+        code: "aborted"
+      });
+    });
+    test18("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();
+      expect18(result).toEqual({ ok: true });
+    });
+    test18("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);
+        expect18.fail("expected queue full error");
+      } catch (error) {
+        expect18(error).toBeInstanceOf(Error);
+        expect18(error.message).toContain(
+          "Queue is full. Limit is"
+        );
+        if (driverTestConfig.clientType !== "http") {
+          expect18(error.group).toBe("queue");
+          expect18(error.code).toBe("full");
+        }
+      }
+    });
+    test18("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);
+        expect18.fail("expected message_too_large error");
+      } catch (error) {
+        expect18(error.group).toBe("queue");
+        expect18(error.code).toBe("message_too_large");
+      }
+    });
+    test18("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;
+      expect18(result).toEqual({
+        status: "completed",
+        response: { echo: { value: 123 } }
+      });
+    });
+    test18("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;
+      expect18(result.status).toBe("timedOut");
+    });
+    test18("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");
+      expect18(first).toEqual({ name: "tasks", body: { value: 789 } });
+      const retried = await handle.receiveOne("tasks", { timeout: 1e3 });
+      expect18(retried).toEqual({ name: "tasks", body: { value: 789 } });
+    });
+    test18("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"
+      );
+      expect18(result).toEqual({
+        group: "queue",
+        code: "previous_message_not_completed"
+      });
+    });
+    test18("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");
+      expect18(result).toEqual({
+        hasComplete: true
+      });
+    });
+    test18("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");
+      expect18(result).toEqual({ hasComplete: true });
+      const next = await handle.receiveOne("nowait", { timeout: 1e3 });
+      expect18(next).toEqual({ name: "nowait", body: { value: "test" } });
+    });
+    test18("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");
+      expect18(result).toEqual({
+        group: "queue",
+        code: "already_completed"
+      });
+    });
+    test18("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 }
+      );
+      expect18(result).toEqual({ status: "timedOut" });
+    });
+    test18("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");
+      expect18(message).toEqual({ name: "one", body: "first" });
+    });
+    test18("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();
+      expect18(message).toEqual({ name: "two", body: "second" });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-run.ts
+import { describe as describe20, expect as expect19, test as test19 } from "vitest";
+function runActorRunTests(driverTestConfig) {
+  var _a;
+  describe20.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Run Tests", () => {
+    test19("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();
+      expect19(state.runStarted).toBe(true);
+      expect19(state.tickCount).toBeGreaterThan(0);
+    });
+    test19("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();
+      expect19(state1.tickCount).toBeGreaterThan(0);
+      const count1 = state1.tickCount;
+      await waitFor(driverTestConfig, 200);
+      const state2 = await actor.getState();
+      expect19(state2.tickCount).toBeGreaterThan(count1);
+    });
+    test19("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();
+      expect19(state1.runStarted).toBe(true);
+      const tickCount1 = state1.tickCount;
+      await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 300);
+      const state2 = await actor.getState();
+      expect19(state2.runStarted).toBe(true);
+      expect19(state2.runExited).toBe(false);
+      expect19(state2.tickCount).toBeGreaterThan(tickCount1);
+    });
+    test19("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();
+      expect19(state.wakeCount).toBe(1);
+      await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 300);
+      const state2 = await actor.getState();
+      expect19(state2.wakeCount).toBe(2);
+    });
+    test19("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();
+      expect19(state.runStarted).toBe(true);
+      expect19(state.messagesReceived.length).toBe(3);
+      expect19(state.messagesReceived[0].body).toEqual({
+        type: "test",
+        value: 1
+      });
+      expect19(state.messagesReceived[1].body).toEqual({
+        type: "test",
+        value: 2
+      });
+      expect19(state.messagesReceived[2].body).toEqual({
+        type: "test",
+        value: 3
+      });
+    });
+    test19("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();
+      expect19(state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 500);
+      const state2 = await actor.getState();
+      expect19(state2.wakeCount).toBeGreaterThan(state1.wakeCount);
+    });
+    test19("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();
+      expect19(state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, 300);
+      const actor2 = client.runWithEarlyExit.getOrCreate([
+        "early-exit-fresh"
+      ]);
+      const state2 = await actor2.getState();
+      expect19(state2.runStarted).toBe(true);
+    });
+    test19("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();
+      expect19(state1.runStarted).toBe(true);
+      await waitFor(driverTestConfig, 300);
+      const actor2 = client.runWithError.getOrCreate(["run-error-fresh"]);
+      const state2 = await actor2.getState();
+      expect19(state2.runStarted).toBe(true);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-stateless.ts
+import { describe as describe21, expect as expect20, test as test20 } from "vitest";
+function runActorStatelessTests(driverTestConfig) {
+  describe21("Actor Stateless Tests", () => {
+    describe21("Stateless Actor Operations", () => {
+      test20("can call actions on stateless actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.ping();
+        expect20(result).toBe("pong");
+      });
+      test20("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);
+        expect20(result).toBe(message);
+      });
+      test20("can access actorId", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate(["test-id"]);
+        const actorId = await instance.getActorId();
+        expect20(actorId).toBeDefined();
+        expect20(typeof actorId).toBe("string");
+      });
+      test20("accessing state throws StateNotEnabled", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.tryGetState();
+        expect20(result.success).toBe(false);
+        expect20(result.error).toContain("state");
+      });
+      test20("accessing db throws DatabaseNotEnabled", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.statelessActor.getOrCreate();
+        const result = await instance.tryGetDb();
+        expect20(result.success).toBe(false);
+        expect20(result.error).toContain("database");
+      });
+      test20("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();
+        expect20(id1).not.toBe(id2);
+      });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-vars.ts
-import { describe as describe17, expect as expect15, test as test15 } from "vitest";
+import { describe as describe22, expect as expect21, test as test21 } from "vitest";
 function runActorVarsTests(driverTestConfig) {
-  describe17("Actor Variables", () => {
-    describe17("Static vars", () => {
-      test15("should provide access to static vars", async (c) => {
+  describe22("Actor Variables", () => {
+    describe22("Static vars", () => {
+      test21("should provide access to static vars", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.staticVarActor.getOrCreate();
         const result = await instance.getVars();
-        expect15(result).toEqual({ counter: 42, name: "test-actor" });
+        expect21(result).toEqual({ counter: 42, name: "test-actor" });
         const name = await instance.getName();
-        expect15(name).toBe("test-actor");
+        expect21(name).toBe("test-actor");
       });
     });
-    describe17("Deep cloning of static vars", () => {
-      test15("should deep clone static vars between actor instances", async (c) => {
+    describe22("Deep cloning of static vars", () => {
+      test21("should deep clone static vars between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.nestedVarActor.getOrCreate([
           "instance1"
@@ -2195,100 +3346,183 @@ function runActorVarsTests(driverTestConfig) {
           "instance2"
         ]);
         const modifiedVars = await instance1.modifyNested();
-        expect15(modifiedVars.nested.value).toBe("modified");
-        expect15(modifiedVars.nested.array).toContain(4);
-        expect15(modifiedVars.nested.obj.key).toBe("new-value");
+        expect21(modifiedVars.nested.value).toBe("modified");
+        expect21(modifiedVars.nested.array).toContain(4);
+        expect21(modifiedVars.nested.obj.key).toBe("new-value");
         const instance2Vars = await instance2.getVars();
-        expect15(instance2Vars.nested.value).toBe("original");
-        expect15(instance2Vars.nested.array).toEqual([1, 2, 3]);
-        expect15(instance2Vars.nested.obj.key).toBe("value");
+        expect21(instance2Vars.nested.value).toBe("original");
+        expect21(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect21(instance2Vars.nested.obj.key).toBe("value");
       });
     });
-    describe17("createVars", () => {
-      test15("should support dynamic vars creation", async (c) => {
+    describe22("createVars", () => {
+      test21("should support dynamic vars creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.dynamicVarActor.getOrCreate();
         const vars = await instance.getVars();
-        expect15(vars).toHaveProperty("random");
-        expect15(vars).toHaveProperty("computed");
-        expect15(typeof vars.random).toBe("number");
-        expect15(typeof vars.computed).toBe("string");
-        expect15(vars.computed).toMatch(/^Actor-\d+$/);
+        expect21(vars).toHaveProperty("random");
+        expect21(vars).toHaveProperty("computed");
+        expect21(typeof vars.random).toBe("number");
+        expect21(typeof vars.computed).toBe("string");
+        expect21(vars.computed).toMatch(/^Actor-\d+$/);
       });
-      test15("should create different vars for different instances", async (c) => {
+      test21("should create different vars for different instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.uniqueVarActor.getOrCreate(["test1"]);
         const instance2 = client.uniqueVarActor.getOrCreate(["test2"]);
         const vars1 = await instance1.getVars();
         const vars2 = await instance2.getVars();
-        expect15(vars1.id).not.toBe(vars2.id);
+        expect21(vars1.id).not.toBe(vars2.id);
       });
     });
-    describe17("Driver Context", () => {
-      test15("should provide access to driver context", async (c) => {
+    describe22("Driver Context", () => {
+      test21("should provide access to driver context", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.driverCtxActor.getOrCreate();
         const vars = await instance.getVars();
-        expect15(vars).toHaveProperty("hasDriverCtx");
+        expect21(vars).toHaveProperty("hasDriverCtx");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-workflow.ts
+import { describe as describe23, expect as expect22, test as test22 } from "vitest";
+function runActorWorkflowTests(driverTestConfig) {
+  describe23("Actor Workflow Tests", () => {
+    var _a;
+    test22("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();
+      expect22(state.runCount).toBeGreaterThan(0);
+      expect22(state.history.length).toBeGreaterThan(0);
+      expect22(state.guardTriggered).toBe(true);
+    });
+    test22("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(WORKFLOW_QUEUE_NAME, {
+        hello: "world"
+      });
+      await waitFor(driverTestConfig, 200);
+      const messages = await actor.getMessages();
+      expect22(messages).toEqual([{ hello: "world" }]);
+    });
+    test22("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 });
+      expect22(result).toEqual({
+        status: "completed",
+        response: { echo: { value: 123 } }
       });
     });
+    test22("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();
+      }
+      expect22(state.outsideDbError).toBe(
+        "db is only available inside workflow steps"
+      );
+      expect22(state.outsideClientError).toBe(
+        "client is only available inside workflow steps"
+      );
+      expect22(state.insideDbCount).toBeGreaterThan(0);
+      expect22(state.insideClientAvailable).toBe(true);
+    });
+    test22("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();
+      expect22(next.ticks).toBeGreaterThan(initial.ticks);
+    });
+    test22.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();
+        expect22(timeline.wakeAts.length).toBeGreaterThanOrEqual(2);
+        expect22(timeline.sleepAts.length).toBeGreaterThanOrEqual(1);
+        const firstSleepDelayMs = timeline.sleepAts[0] - timeline.wakeAts[0];
+        expect22(firstSleepDelayMs).toBeLessThan(1800);
+      }
+    );
   });
 }
 
 // src/driver-test-suite/tests/manager-driver.ts
-import { describe as describe18, expect as expect16, test as test16 } from "vitest";
+import { describe as describe24, expect as expect23, test as test23 } from "vitest";
 function runManagerDriverTests(driverTestConfig) {
-  describe18("Manager Driver Tests", () => {
-    describe18("Client Connection Methods", () => {
-      test16("connect() - finds or creates a actor", async (c) => {
+  describe24("Manager Driver Tests", () => {
+    describe24("Client Connection Methods", () => {
+      test23("connect() - finds or creates a actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterA = client.counter.getOrCreate();
         await counterA.increment(5);
         const counterAAgain = client.counter.getOrCreate();
         const count = await counterAAgain.increment(0);
-        expect16(count).toBe(5);
+        expect23(count).toBe(5);
         const counterB = client.counter.getOrCreate([
           "counter-b",
           "testing"
         ]);
         await counterB.increment(10);
         const countB = await counterB.increment(0);
-        expect16(countB).toBe(10);
+        expect23(countB).toBe(10);
       });
-      test16("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+      test23("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = ["duplicate-actor-test", crypto.randomUUID()];
         const counter = client.counter.getOrCreate(uniqueKey);
         await counter.increment(5);
         try {
           await client.counter.create(uniqueKey);
-          expect16.fail("did not error on duplicate create");
+          expect23.fail("did not error on duplicate create");
         } catch (err) {
-          expect16(err.group).toBe("actor");
-          expect16(err.code).toBe("duplicate_key");
+          expect23(err.group).toBe("actor");
+          expect23(err.code).toBe("duplicate_key");
         }
         const count = await counter.increment(0);
-        expect16(count).toBe(5);
+        expect23(count).toBe(5);
       });
     });
-    describe18("Connection Options", () => {
-      test16("get without create prevents actor creation", async (c) => {
+    describe24("Connection Options", () => {
+      test23("get without create prevents actor creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const nonexistentId = `nonexistent-${crypto.randomUUID()}`;
         try {
           await client.counter.get([nonexistentId]).resolve();
-          expect16.fail("did not error for get");
+          expect23.fail("did not error for get");
         } catch (err) {
-          expect16(err.group).toBe("actor");
-          expect16(err.code).toBe("not_found");
+          expect23(err.group).toBe("actor");
+          expect23(err.code).toBe("not_found");
         }
         const createdCounter = client.counter.getOrCreate(nonexistentId);
         await createdCounter.increment(3);
         const retrievedCounter = client.counter.get(nonexistentId);
         const count = await retrievedCounter.increment(0);
-        expect16(count).toBe(3);
+        expect23(count).toBe(3);
       });
-      test16("connection params are passed to actors", async (c) => {
+      test23("connection params are passed to actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counter = client.counter.getOrCreate(void 0, {
           params: {
@@ -2299,20 +3533,20 @@ function runManagerDriverTests(driverTestConfig) {
         });
         await counter.increment(1);
         const count = await counter.increment(0);
-        expect16(count).toBe(1);
+        expect23(count).toBe(1);
       });
     });
-    describe18("Actor Creation & Retrieval", () => {
-      test16("creates and retrieves actors by ID", async (c) => {
+    describe24("Actor Creation & Retrieval", () => {
+      test23("creates and retrieves actors by ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueId = `test-counter-${crypto.randomUUID()}`;
         const counter = client.counter.getOrCreate([uniqueId]);
         await counter.increment(10);
         const retrievedCounter = client.counter.getOrCreate([uniqueId]);
         const count = await retrievedCounter.increment(0);
-        expect16(count).toBe(10);
+        expect23(count).toBe(10);
       });
-      test16("passes input to actor during creation", async (c) => {
+      test23("passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const testInput = {
           name: "test-actor",
@@ -2323,17 +3557,17 @@ function runManagerDriverTests(driverTestConfig) {
           input: testInput
         });
         const inputs = await actor.getInputs();
-        expect16(inputs.initialInput).toEqual(testInput);
-        expect16(inputs.onCreateInput).toEqual(testInput);
+        expect23(inputs.initialInput).toEqual(testInput);
+        expect23(inputs.onCreateInput).toEqual(testInput);
       });
-      test16("input is undefined when not provided", async (c) => {
+      test23("input is undefined when not provided", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const actor = await client.inputActor.create();
         const inputs = await actor.getInputs();
-        expect16(inputs.initialInput).toBeUndefined();
-        expect16(inputs.onCreateInput).toBeUndefined();
+        expect23(inputs.initialInput).toBeUndefined();
+        expect23(inputs.onCreateInput).toBeUndefined();
       });
-      test16("getOrCreate passes input to actor during creation", async (c) => {
+      test23("getOrCreate passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = [`input-test-${crypto.randomUUID()}`];
         const testInput = {
@@ -2345,16 +3579,22 @@ function runManagerDriverTests(driverTestConfig) {
           createWithInput: testInput
         });
         const inputs = await actor.getInputs();
-        expect16(inputs.initialInput).toEqual(testInput);
-        expect16(inputs.onCreateInput).toEqual(testInput);
+        expect23(inputs.initialInput).toEqual(testInput);
+        expect23(inputs.onCreateInput).toEqual(testInput);
         const existingActor = client.inputActor.getOrCreate(uniqueKey);
         const existingInputs = await existingActor.getInputs();
-        expect16(existingInputs.initialInput).toEqual(testInput);
-        expect16(existingInputs.onCreateInput).toEqual(testInput);
+        expect23(existingInputs.initialInput).toEqual(testInput);
+        expect23(existingInputs.onCreateInput).toEqual(testInput);
       });
     });
-    describe18("Key Matching", () => {
-      test16("matches actors only with exactly the same keys", async (c) => {
+    describe24("Key Matching", () => {
+      test23("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);
+        expect23(await counter.getKey()).toEqual(multiPartKey);
+      });
+      test23("matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
           "counter-match",
@@ -2368,20 +3608,20 @@ function runManagerDriverTests(driverTestConfig) {
           "us-east"
         ]);
         const exactMatchCount = await exactMatchCounter.increment(0);
-        expect16(exactMatchCount).toBe(10);
+        expect23(exactMatchCount).toBe(10);
         const subsetMatchCounter = client.counter.getOrCreate([
           "counter-match",
           "test"
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
-        expect16(subsetMatchCount).toBe(0);
+        expect23(subsetMatchCount).toBe(0);
         const singleKeyCounter = client.counter.getOrCreate([
           "counter-match"
         ]);
         const singleKeyCount = await singleKeyCounter.increment(0);
-        expect16(singleKeyCount).toBe(0);
+        expect23(singleKeyCount).toBe(0);
       });
-      test16("string key matches array with single string key", async (c) => {
+      test23("string key matches array with single string key", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const stringKeyCounter = client.counter.getOrCreate("string-key-test");
         await stringKeyCounter.increment(7);
@@ -2389,20 +3629,20 @@ function runManagerDriverTests(driverTestConfig) {
           "string-key-test"
         ]);
         const count = await arrayKeyCounter.increment(0);
-        expect16(count).toBe(7);
+        expect23(count).toBe(7);
       });
-      test16("undefined key matches empty array key and no key", async (c) => {
+      test23("undefined key matches empty array key and no key", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const undefinedKeyCounter = client.counter.getOrCreate(void 0);
         await undefinedKeyCounter.increment(12);
         const emptyArrayKeyCounter = client.counter.getOrCreate([]);
         const emptyArrayCount = await emptyArrayKeyCounter.increment(0);
-        expect16(emptyArrayCount).toBe(12);
+        expect23(emptyArrayCount).toBe(12);
         const noKeyCounter = client.counter.getOrCreate();
         const noKeyCount = await noKeyCounter.increment(0);
-        expect16(noKeyCount).toBe(12);
+        expect23(noKeyCount).toBe(12);
       });
-      test16("no keys does not match actors with keys", async (c) => {
+      test23("no keys does not match actors with keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const keyedCounter = client.counter.getOrCreate([
           "counter-with-keys",
@@ -2411,9 +3651,9 @@ function runManagerDriverTests(driverTestConfig) {
         await keyedCounter.increment(15);
         const noKeysCounter = client.counter.getOrCreate();
         const count = await noKeysCounter.increment(10);
-        expect16(count).toBe(10);
+        expect23(count).toBe(10);
       });
-      test16("actors with keys match actors with no keys", async (c) => {
+      test23("actors with keys match actors with no keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const noKeysCounter = client.counter.getOrCreate();
         await noKeysCounter.increment(25);
@@ -2422,11 +3662,11 @@ function runManagerDriverTests(driverTestConfig) {
           "prod"
         ]);
         const keyedCount = await keyedCounter.increment(0);
-        expect16(keyedCount).toBe(0);
+        expect23(keyedCount).toBe(0);
       });
     });
-    describe18("Multiple Actor Instances", () => {
-      test16("creates multiple actor instances of the same type", async (c) => {
+    describe24("Multiple Actor Instances", () => {
+      test23("creates multiple actor instances of the same type", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.counter.getOrCreate(["multi-1"]);
         const instance2 = client.counter.getOrCreate(["multi-2"]);
@@ -2437,35 +3677,35 @@ function runManagerDriverTests(driverTestConfig) {
         const retrieved1 = client.counter.getOrCreate(["multi-1"]);
         const retrieved2 = client.counter.getOrCreate(["multi-2"]);
         const retrieved3 = client.counter.getOrCreate(["multi-3"]);
-        expect16(await retrieved1.increment(0)).toBe(1);
-        expect16(await retrieved2.increment(0)).toBe(2);
-        expect16(await retrieved3.increment(0)).toBe(3);
+        expect23(await retrieved1.increment(0)).toBe(1);
+        expect23(await retrieved2.increment(0)).toBe(2);
+        expect23(await retrieved3.increment(0)).toBe(3);
       });
-      test16("handles default instance with no explicit ID", async (c) => {
+      test23("handles default instance with no explicit ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const defaultCounter = client.counter.getOrCreate();
         await defaultCounter.increment(5);
         const sameDefaultCounter = client.counter.getOrCreate();
         const count = await sameDefaultCounter.increment(0);
-        expect16(count).toBe(5);
+        expect23(count).toBe(5);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http.ts
-import { describe as describe19, expect as expect17, test as test17 } from "vitest";
+import { describe as describe25, expect as expect24, test as test24 } from "vitest";
 function runRawHttpTests(driverTestConfig) {
-  describe19("raw http", () => {
-    test17("should handle raw HTTP GET requests", async (c) => {
+  describe25("raw http", () => {
+    test24("should handle raw HTTP GET requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["test"]);
       const helloResponse = await actor.fetch("api/hello");
-      expect17(helloResponse.ok).toBe(true);
+      expect24(helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
-      expect17(helloData).toEqual({ message: "Hello from actor!" });
+      expect24(helloData).toEqual({ message: "Hello from actor!" });
     });
-    test17("should handle raw HTTP POST requests with echo", async (c) => {
+    test24("should handle raw HTTP POST requests with echo", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["test"]);
       const testData = { test: "data", number: 123 };
@@ -2476,22 +3716,22 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: JSON.stringify(testData)
       });
-      expect17(echoResponse.ok).toBe(true);
+      expect24(echoResponse.ok).toBe(true);
       const echoData = await echoResponse.json();
-      expect17(echoData).toEqual(testData);
+      expect24(echoData).toEqual(testData);
     });
-    test17("should track state across raw HTTP requests", async (c) => {
+    test24("should track state across raw HTTP requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["state-test"]);
       await actor.fetch("api/hello");
       await actor.fetch("api/hello");
       await actor.fetch("api/state");
       const stateResponse = await actor.fetch("api/state");
-      expect17(stateResponse.ok).toBe(true);
+      expect24(stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
-      expect17(stateData.requestCount).toBe(4);
+      expect24(stateData.requestCount).toBe(4);
     });
-    test17("should pass headers correctly", async (c) => {
+    test24("should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
@@ -2501,44 +3741,44 @@ function runRawHttpTests(driverTestConfig) {
       const response = await actor.fetch("api/headers", {
         headers: customHeaders
       });
-      expect17(response.ok).toBe(true);
+      expect24(response.ok).toBe(true);
       const headers = await response.json();
-      expect17(headers["x-custom-header"]).toBe("test-value");
-      expect17(headers["x-another-header"]).toBe("another-value");
+      expect24(headers["x-custom-header"]).toBe("test-value");
+      expect24(headers["x-another-header"]).toBe("another-value");
     });
-    test17("should return 404 for unhandled paths", async (c) => {
+    test24("should return 404 for unhandled paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["404-test"]);
       const response = await actor.fetch("api/nonexistent");
-      expect17(response.ok).toBe(false);
-      expect17(response.status).toBe(404);
+      expect24(response.ok).toBe(false);
+      expect24(response.status).toBe(404);
     });
-    test17("should return 404 when no onRequest handler defined", async (c) => {
+    test24("should return 404 when no onRequest handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpNoHandlerActor.getOrCreate([
         "no-handler"
       ]);
       const response = await actor.fetch("api/anything");
-      expect17(response.ok).toBe(false);
-      expect17(response.status).toBe(404);
+      expect24(response.ok).toBe(false);
+      expect24(response.status).toBe(404);
     });
-    test17("should return 500 error when onRequest returns void", async (c) => {
+    test24("should return 500 error when onRequest returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpVoidReturnActor.getOrCreate([
         "void-return"
       ]);
       const response = await actor.fetch("api/anything");
-      expect17(response.ok).toBe(false);
-      expect17(response.status).toBe(500);
+      expect24(response.ok).toBe(false);
+      expect24(response.status).toBe(500);
       try {
         const errorData = await response.json();
-        expect17(errorData.message).toContain(
+        expect24(errorData.message).toContain(
           "onRequest handler must return a Response"
         );
       } catch {
       }
     });
-    test17("should handle different HTTP methods", async (c) => {
+    test24("should handle different HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["methods-test"]);
       const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
@@ -2548,17 +3788,17 @@ function runRawHttpTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "POST") {
-          expect17(response.ok).toBe(true);
+          expect24(response.ok).toBe(true);
           const data = await response.json();
-          expect17(data).toEqual({ method });
+          expect24(data).toEqual({ method });
         } else if (method === "GET") {
-          expect17(response.status).toBe(404);
+          expect24(response.status).toBe(404);
         } else {
-          expect17(response.status).toBe(404);
+          expect24(response.status).toBe(404);
         }
       }
     });
-    test17("should handle binary data", async (c) => {
+    test24("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["binary-test"]);
       const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
@@ -2569,82 +3809,82 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: binaryData
       });
-      expect17(response.ok).toBe(true);
+      expect24(response.ok).toBe(true);
       const responseBuffer = await response.arrayBuffer();
       const responseArray = new Uint8Array(responseBuffer);
-      expect17(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+      expect24(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
     });
-    test17("should work with Hono router using createVars", async (c) => {
+    test24("should work with Hono router using createVars", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
       const rootResponse = await actor.fetch("/");
-      expect17(rootResponse.ok).toBe(true);
+      expect24(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect17(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      expect24(rootData).toEqual({ message: "Welcome to Hono actor!" });
       const usersResponse = await actor.fetch("/users");
-      expect17(usersResponse.ok).toBe(true);
+      expect24(usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
-      expect17(users).toEqual([
+      expect24(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
       const userResponse = await actor.fetch("/users/1");
-      expect17(userResponse.ok).toBe(true);
+      expect24(userResponse.ok).toBe(true);
       const user = await userResponse.json();
-      expect17(user).toEqual({ id: 1, name: "Alice" });
+      expect24(user).toEqual({ id: 1, name: "Alice" });
       const newUser = { name: "Charlie" };
       const createResponse = await actor.fetch("/users", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(newUser)
       });
-      expect17(createResponse.ok).toBe(true);
-      expect17(createResponse.status).toBe(201);
+      expect24(createResponse.ok).toBe(true);
+      expect24(createResponse.status).toBe(201);
       const createdUser = await createResponse.json();
-      expect17(createdUser).toEqual({ id: 3, name: "Charlie" });
+      expect24(createdUser).toEqual({ id: 3, name: "Charlie" });
       const updateData = { name: "Alice Updated" };
       const updateResponse = await actor.fetch("/users/1", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(updateData)
       });
-      expect17(updateResponse.ok).toBe(true);
+      expect24(updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
-      expect17(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      expect24(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
       const deleteResponse = await actor.fetch("/users/2", {
         method: "DELETE"
       });
-      expect17(deleteResponse.ok).toBe(true);
+      expect24(deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
-      expect17(deleteResult).toEqual({ message: "User 2 deleted" });
+      expect24(deleteResult).toEqual({ message: "User 2 deleted" });
       const notFoundResponse = await actor.fetch("/api/unknown");
-      expect17(notFoundResponse.ok).toBe(false);
-      expect17(notFoundResponse.status).toBe(404);
+      expect24(notFoundResponse.ok).toBe(false);
+      expect24(notFoundResponse.status).toBe(404);
     });
-    test17("should handle paths with and without leading slashes", async (c) => {
+    test24("should handle paths with and without leading slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["path-test"]);
       const responseWithoutSlash = await actor.fetch("api/hello");
-      expect17(responseWithoutSlash.ok).toBe(true);
+      expect24(responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
-      expect17(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      expect24(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
       const responseWithSlash = await actor.fetch("/api/hello");
-      expect17(responseWithSlash.ok).toBe(true);
+      expect24(responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
-      expect17(dataWithSlash).toEqual({ message: "Hello from actor!" });
+      expect24(dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
-    test17("should not create double slashes in request URLs", async (c) => {
+    test24("should not create double slashes in request URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["url-test"]);
       const response = await actor.fetch("/users");
-      expect17(response.ok).toBe(true);
+      expect24(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data).toEqual([
+      expect24(data).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test17("should handle forwarded requests correctly without double slashes", async (c) => {
+    test24("should handle forwarded requests correctly without double slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
       const truncatedPath = "/users";
@@ -2656,14 +3896,14 @@ function runRawHttpTests(driverTestConfig) {
         truncatedPath,
         newRequest
       );
-      expect17(response.ok).toBe(true);
+      expect24(response.ok).toBe(true);
       const users = await response.json();
-      expect17(users).toEqual([
+      expect24(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test17("example fix: should properly forward requests using just Request object", async (c) => {
+    test24("example fix: should properly forward requests using just Request object", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
       const truncatedPath = "/users/1";
@@ -2672,11 +3912,11 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor.fetch(newRequest);
-      expect17(response.ok).toBe(true);
+      expect24(response.ok).toBe(true);
       const user = await response.json();
-      expect17(user).toEqual({ id: 1, name: "Alice" });
+      expect24(user).toEqual({ id: 1, name: "Alice" });
     });
-    test17("should support standard fetch API with URL and Request objects", async (c) => {
+    test24("should support standard fetch API with URL and Request objects", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
       const url = new URL("/api/echo", "http://example.com");
@@ -2685,18 +3925,18 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
       });
-      expect17(urlResponse.ok).toBe(true);
+      expect24(urlResponse.ok).toBe(true);
       const urlData = await urlResponse.json();
-      expect17(urlData).toEqual({ from: "URL object" });
+      expect24(urlData).toEqual({ from: "URL object" });
       const request = new Request("http://example.com/api/echo", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "Request object" })
       });
       const requestResponse = await actor.fetch(request);
-      expect17(requestResponse.ok).toBe(true);
+      expect24(requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
-      expect17(requestData).toEqual({ from: "Request object" });
+      expect24(requestData).toEqual({ from: "Request object" });
       const request2 = new Request("http://example.com/api/headers", {
         method: "GET",
         headers: { "X-Original": "request-header" }
@@ -2704,19 +3944,19 @@ function runRawHttpTests(driverTestConfig) {
       const overrideResponse = await actor.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
-      expect17(overrideResponse.ok).toBe(true);
+      expect24(overrideResponse.ok).toBe(true);
       const headers = await overrideResponse.json();
-      expect17(headers["x-override"]).toBe("init-header");
-      expect17(headers["x-original"]).toBe("request-header");
+      expect24(headers["x-override"]).toBe("init-header");
+      expect24(headers["x-original"]).toBe("request-header");
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http-request-properties.ts
-import { describe as describe20, expect as expect18, test as test18 } from "vitest";
+import { describe as describe26, expect as expect25, test as test25 } from "vitest";
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
-  describe20("raw http request properties", () => {
-    test18("should pass all Request properties correctly to onRequest", async (c) => {
+  describe26("raw http request properties", () => {
+    test25("should pass all Request properties correctly to onRequest", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2730,22 +3970,22 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify({ test: "data" })
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.url).toContain("/test/path?foo=bar&baz=qux");
-      expect18(data.pathname).toBe("/test/path");
-      expect18(data.search).toBe("?foo=bar&baz=qux");
-      expect18(data.searchParams).toEqual({
+      expect25(data.url).toContain("/test/path?foo=bar&baz=qux");
+      expect25(data.pathname).toBe("/test/path");
+      expect25(data.search).toBe("?foo=bar&baz=qux");
+      expect25(data.searchParams).toEqual({
         foo: "bar",
         baz: "qux"
       });
-      expect18(data.method).toBe("POST");
-      expect18(data.headers["content-type"]).toBe("application/json");
-      expect18(data.headers["x-custom-header"]).toBe("custom-value");
-      expect18(data.headers["authorization"]).toBe("Bearer test-token");
-      expect18(data.body).toEqual({ test: "data" });
+      expect25(data.method).toBe("POST");
+      expect25(data.headers["content-type"]).toBe("application/json");
+      expect25(data.headers["x-custom-header"]).toBe("custom-value");
+      expect25(data.headers["authorization"]).toBe("Bearer test-token");
+      expect25(data.body).toEqual({ test: "data" });
     });
-    test18("should handle GET requests with no body", async (c) => {
+    test25("should handle GET requests with no body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2753,12 +3993,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch("test/get", {
         method: "GET"
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.method).toBe("GET");
-      expect18(data.body).toBeNull();
+      expect25(data.method).toBe("GET");
+      expect25(data.body).toBeNull();
     });
-    test18("should handle different content types", async (c) => {
+    test25("should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2773,12 +4013,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: formData.toString()
       });
-      expect18(formResponse.ok).toBe(true);
+      expect25(formResponse.ok).toBe(true);
       const formResult = await formResponse.json();
-      expect18(formResult.headers["content-type"]).toBe(
+      expect25(formResult.headers["content-type"]).toBe(
         "application/x-www-form-urlencoded"
       );
-      expect18(formResult.bodyText).toBe("field1=value1&field2=value2");
+      expect25(formResult.bodyText).toBe("field1=value1&field2=value2");
       const textResponse = await actor.fetch("test/text", {
         method: "POST",
         headers: {
@@ -2786,12 +4026,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: "Hello, World!"
       });
-      expect18(textResponse.ok).toBe(true);
+      expect25(textResponse.ok).toBe(true);
       const textResult = await textResponse.json();
-      expect18(textResult.headers["content-type"]).toBe("text/plain");
-      expect18(textResult.bodyText).toBe("Hello, World!");
+      expect25(textResult.headers["content-type"]).toBe("text/plain");
+      expect25(textResult.bodyText).toBe("Hello, World!");
     });
-    test18("should preserve all header casing and values", async (c) => {
+    test25("should preserve all header casing and values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2805,38 +4045,38 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           "X-Request-ID": "12345"
         }
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.headers["accept"]).toBe("application/json");
-      expect18(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
-      expect18(data.headers["cache-control"]).toBe("no-cache");
-      expect18(data.headers["user-agent"]).toBeTruthy();
-      expect18(data.headers["x-request-id"]).toBe("12345");
+      expect25(data.headers["accept"]).toBe("application/json");
+      expect25(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
+      expect25(data.headers["cache-control"]).toBe("no-cache");
+      expect25(data.headers["user-agent"]).toBeTruthy();
+      expect25(data.headers["x-request-id"]).toBe("12345");
     });
-    test18("should handle empty and special URL paths", async (c) => {
+    test25("should handle empty and special URL paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const rootResponse = await actor.fetch("");
-      expect18(rootResponse.ok).toBe(true);
+      expect25(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect18(rootData.pathname).toBe("/");
+      expect25(rootData.pathname).toBe("/");
       const specialResponse = await actor.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
-      expect18(specialResponse.ok).toBe(true);
+      expect25(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect18(specialData.pathname).toMatch(
+      expect25(specialData.pathname).toMatch(
         /path.*with.*spaces.*and.*slashes/
       );
       const fragmentResponse = await actor.fetch("test/path#fragment");
-      expect18(fragmentResponse.ok).toBe(true);
+      expect25(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
-      expect18(fragmentData.pathname).toBe("/test/path");
-      expect18(fragmentData.hash).toBe("");
+      expect25(fragmentData.pathname).toBe("/test/path");
+      expect25(fragmentData.hash).toBe("");
     });
-    test18("should handle request properties for all HTTP methods", async (c) => {
+    test25("should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2860,21 +4100,21 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           }
         );
         if (method === "HEAD") {
-          expect18(response.status).toBe(200);
+          expect25(response.status).toBe(200);
           const text = await response.text();
-          expect18(text).toBe("");
+          expect25(text).toBe("");
         } else if (method === "OPTIONS") {
-          expect18(response.status).toBe(204);
+          expect25(response.status).toBe(204);
           const text = await response.text();
-          expect18(text).toBe("");
+          expect25(text).toBe("");
         } else {
-          expect18(response.ok).toBe(true);
+          expect25(response.ok).toBe(true);
           const data = await response.json();
-          expect18(data.method).toBe(method);
+          expect25(data.method).toBe(method);
         }
       }
     });
-    test18("should handle complex query parameters", async (c) => {
+    test25("should handle complex query parameters", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2882,13 +4122,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.searchParams.key).toBe("value2");
-      expect18(data.searchParams["array[]"]).toBe("2");
-      expect18(data.searchParams["nested[prop]"]).toBe("val");
+      expect25(data.searchParams.key).toBe("value2");
+      expect25(data.searchParams["array[]"]).toBe("2");
+      expect25(data.searchParams["nested[prop]"]).toBe("val");
     });
-    test18("should handle multipart form data", async (c) => {
+    test25("should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2912,27 +4152,27 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.headers["content-type"]).toContain(
+      expect25(data.headers["content-type"]).toContain(
         "multipart/form-data"
       );
-      expect18(data.bodyText).toContain("field1");
-      expect18(data.bodyText).toContain("value1");
+      expect25(data.bodyText).toContain("field1");
+      expect25(data.bodyText).toContain("value1");
     });
-    test18("should handle very long URLs", async (c) => {
+    test25("should handle very long URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const longValue = "x".repeat(1e3);
       const response = await actor.fetch(`test/long?param=${longValue}`);
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.searchParams.param).toBe(longValue);
-      expect18(data.search.length).toBeGreaterThan(1e3);
+      expect25(data.searchParams.param).toBe(longValue);
+      expect25(data.search.length).toBeGreaterThan(1e3);
     });
-    test18.skip("should handle large request bodies", async (c) => {
+    test25.skip("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2949,11 +4189,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify(largeArray)
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.body).toHaveLength(1e4);
+      expect25(data.body).toHaveLength(1e4);
     });
-    test18("should handle missing content-type header", async (c) => {
+    test25("should handle missing content-type header", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2962,11 +4202,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         method: "POST",
         body: "plain text without content-type"
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.bodyText).toBe("plain text without content-type");
+      expect25(data.bodyText).toBe("plain text without content-type");
     });
-    test18("should handle empty request body", async (c) => {
+    test25("should handle empty request body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2978,9 +4218,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: ""
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
     });
-    test18("should handle custom HTTP methods", async (c) => {
+    test25("should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -2991,12 +4231,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         });
         if (response.ok) {
           const data = await response.json();
-          expect18(data.method).toBe("CUSTOM");
+          expect25(data.method).toBe("CUSTOM");
         }
       } catch (error) {
       }
     });
-    test18("should handle cookies in headers", async (c) => {
+    test25("should handle cookies in headers", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3006,13 +4246,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
       });
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.headers.cookie).toBe(
+      expect25(data.headers.cookie).toBe(
         "session=abc123; user=test; preferences=dark_mode"
       );
     });
-    test18("should handle URL encoding properly", async (c) => {
+    test25("should handle URL encoding properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3020,13 +4260,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch(
         "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
       );
-      expect18(response.ok).toBe(true);
+      expect25(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.searchParams.special).toBe(" !@#$%^&");
-      expect18(data.searchParams.unicode).toBe("\u2713");
-      expect18(data.searchParams.email).toBe("test@example.com");
+      expect25(data.searchParams.special).toBe(" !@#$%^&");
+      expect25(data.searchParams.unicode).toBe("\u2713");
+      expect25(data.searchParams.email).toBe("test@example.com");
     });
-    test18("should handle concurrent requests maintaining separate contexts", async (c) => {
+    test25("should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3050,27 +4290,27 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const results = await Promise.all(
         responses.map((r) => r.json())
       );
-      expect18(results[0].searchParams.id).toBe("1");
-      expect18(results[0].method).toBe("POST");
-      expect18(results[0].body).toEqual({ request: 1 });
-      expect18(results[1].searchParams.id).toBe("2");
-      expect18(results[1].method).toBe("PUT");
-      expect18(results[1].body).toEqual({ request: 2 });
-      expect18(results[2].searchParams.id).toBe("3");
-      expect18(results[2].method).toBe("DELETE");
-      expect18(results[2].body).toBeNull();
+      expect25(results[0].searchParams.id).toBe("1");
+      expect25(results[0].method).toBe("POST");
+      expect25(results[0].body).toEqual({ request: 1 });
+      expect25(results[1].searchParams.id).toBe("2");
+      expect25(results[1].method).toBe("PUT");
+      expect25(results[1].body).toEqual({ request: 2 });
+      expect25(results[2].searchParams.id).toBe("3");
+      expect25(results[2].method).toBe("DELETE");
+      expect25(results[2].body).toBeNull();
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-websocket.ts
-import { describe as describe21, expect as expect19, test as test19 } from "vitest";
+import { describe as describe27, expect as expect26, test as test26 } from "vitest";
 function runRawWebSocketTests(driverTestConfig) {
-  describe21("raw websocket", () => {
-    test19("should establish raw WebSocket connection", async (c) => {
+  describe27("raw websocket", () => {
+    test26("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();
@@ -3094,14 +4334,14 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect19(welcomeMessage.type).toBe("welcome");
-      expect19(welcomeMessage.connectionCount).toBe(1);
+      expect26(welcomeMessage.type).toBe("welcome");
+      expect26(welcomeMessage.connectionCount).toBe(1);
       ws.close();
     });
-    test19("should echo messages", async (c) => {
+    test26("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(), {
@@ -3126,13 +4366,13 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect19(echoMessage).toEqual(testMessage);
+      expect26(echoMessage).toEqual(testMessage);
       ws.close();
     });
-    test19("should handle ping/pong protocol", async (c) => {
+    test26("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(), {
@@ -3155,14 +4395,14 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect19(pongMessage.type).toBe("pong");
-      expect19(pongMessage.timestamp).toBeDefined();
+      expect26(pongMessage.type).toBe("pong");
+      expect26(pongMessage.timestamp).toBeDefined();
       ws.close();
     });
-    test19("should track stats across connections", async (c) => {
+    test26("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
@@ -3171,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
@@ -3203,20 +4443,20 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws1.send(JSON.stringify({ type: "getStats" }));
       const stats = await statsPromise;
-      expect19(stats.connectionCount).toBe(2);
-      expect19(stats.messageCount).toBe(4);
+      expect26(stats.connectionCount).toBe(2);
+      expect26(stats.messageCount).toBe(4);
       const actionStats = await actor1.getStats();
-      expect19(actionStats.connectionCount).toBe(2);
-      expect19(actionStats.messageCount).toBe(4);
+      expect26(actionStats.connectionCount).toBe(2);
+      expect26(actionStats.messageCount).toBe(4);
       ws1.close();
       ws2.close();
     });
-    test19("should handle binary data", async (c) => {
+    test26("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, 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(), {
@@ -3244,7 +4484,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const smallData = new Uint8Array([1, 2, 3, 4, 5]);
       ws.send(smallData);
       const smallReversed = await receiveBinaryMessage();
-      expect19(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
+      expect26(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
       const largeData = new Uint8Array(1024);
       for (let i = 0; i < largeData.length; i++) {
         largeData[i] = i % 256;
@@ -3252,16 +4492,16 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        expect19(largeReversed[i]).toBe(
+        expect26(largeReversed[i]).toBe(
           largeData[largeData.length - 1 - i]
         );
       }
       ws.close();
     });
-    test19("should work with custom paths", async (c) => {
+    test26("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();
@@ -3278,13 +4518,13 @@ function runRawWebSocketTests(driverTestConfig) {
           { once: true }
         );
       });
-      expect19(welcomeMessage.type).toBe("welcome");
+      expect26(welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    test19("should handle connection close properly", async (c) => {
+    test26("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(), {
@@ -3294,7 +4534,7 @@ function runRawWebSocketTests(driverTestConfig) {
         });
       }
       const initialStats = await actor.getStats();
-      expect19(initialStats.connectionCount).toBe(1);
+      expect26(initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve) => {
         ws.addEventListener("close", () => resolve(), { once: true });
       });
@@ -3308,14 +4548,14 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect26(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test19("should properly handle onWebSocket open and close events", async (c) => {
+    test26("should properly handle onWebSocket open and close events", async (c) => {
       const { client } = await setupDriverTest(c, 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);
@@ -3330,9 +4570,9 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws1.addEventListener("close", reject);
       });
-      expect19(welcome1.type).toBe("welcome");
-      expect19(welcome1.connectionCount).toBe(1);
-      const ws2 = await actor.websocket();
+      expect26(welcome1.type).toBe("welcome");
+      expect26(welcome1.connectionCount).toBe(1);
+      const ws2 = await actor.webSocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
         ws2.addEventListener("close", reject);
@@ -3347,10 +4587,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws2.addEventListener("close", reject);
       });
-      expect19(welcome2.type).toBe("welcome");
-      expect19(welcome2.connectionCount).toBe(2);
+      expect26(welcome2.type).toBe("welcome");
+      expect26(welcome2.connectionCount).toBe(2);
       const midStats = await actor.getStats();
-      expect19(midStats.connectionCount).toBe(2);
+      expect26(midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve) => {
         ws1.addEventListener("close", () => resolve(), { once: true });
@@ -3363,7 +4603,7 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect19(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      expect26(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
       await new Promise((resolve) => {
         ws2.addEventListener("close", () => resolve(), { once: true });
@@ -3376,14 +4616,14 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect26(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test19("should handle query parameters in websocket paths", async (c) => {
+    test26("should handle query parameters in websocket paths", async (c) => {
       const { client } = await setupDriverTest(c, 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) => {
@@ -3401,17 +4641,17 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect19(requestInfo.url).toContain("api/v1/stream");
-      expect19(requestInfo.url).toContain("token=abc123");
-      expect19(requestInfo.url).toContain("user=test");
+      expect26(requestInfo.url).toContain("api/v1/stream");
+      expect26(requestInfo.url).toContain("token=abc123");
+      expect26(requestInfo.url).toContain("user=test");
       ws.close();
     });
-    test19("should handle query parameters on base websocket path (no subpath)", async (c) => {
+    test26("should handle query parameters on base websocket path (no subpath)", async (c) => {
       const { client } = await setupDriverTest(c, 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);
@@ -3430,18 +4670,18 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect19(requestInfo.url).toContain("token=secret");
-      expect19(requestInfo.url).toContain("session=123");
+      expect26(requestInfo.url).toContain("token=secret");
+      expect26(requestInfo.url).toContain("session=123");
       ws.close();
     });
   });
 }
 
 // src/driver-test-suite/tests/request-access.ts
-import { describe as describe22, expect as expect20, test as test20 } from "vitest";
+import { describe as describe28, expect as expect27, test as test27 } from "vitest";
 function runRequestAccessTests(driverTestConfig) {
-  describe22("Request Access in Lifecycle Hooks", () => {
-    test20("should have access to request object in onBeforeConnect and createConnState", async (c) => {
+  describe28("Request Access in Lifecycle Hooks", () => {
+    test27("should have access to request object in onBeforeConnect and createConnState", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-request"],
@@ -3452,23 +4692,23 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect20(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect20(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
-        expect20(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        expect20(
+        expect27(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect27(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect27(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect27(
           requestInfo.onBeforeConnect.requestHeaders
         ).toBeDefined();
-        expect20(requestInfo.createConnState.hasRequest).toBe(true);
-        expect20(requestInfo.createConnState.requestUrl).toBeDefined();
-        expect20(requestInfo.createConnState.requestMethod).toBeDefined();
-        expect20(
+        expect27(requestInfo.createConnState.hasRequest).toBe(true);
+        expect27(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect27(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect27(
           requestInfo.createConnState.requestHeaders
         ).toBeDefined();
       } else {
       }
       await connection.dispose();
     });
-    test20("should not have request when trackRequest is false", async (c) => {
+    test27("should not have request when trackRequest is false", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-no-request"],
@@ -3478,21 +4718,21 @@ function runRequestAccessTests(driverTestConfig) {
       );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
-      expect20(requestInfo.onBeforeConnect.hasRequest).toBe(false);
-      expect20(requestInfo.onBeforeConnect.requestUrl).toBeNull();
-      expect20(requestInfo.onBeforeConnect.requestMethod).toBeNull();
-      expect20(
+      expect27(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect27(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect27(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect27(
         Object.keys(requestInfo.onBeforeConnect.requestHeaders)
       ).toHaveLength(0);
-      expect20(requestInfo.createConnState.hasRequest).toBe(false);
-      expect20(requestInfo.createConnState.requestUrl).toBeNull();
-      expect20(requestInfo.createConnState.requestMethod).toBeNull();
-      expect20(
+      expect27(requestInfo.createConnState.hasRequest).toBe(false);
+      expect27(requestInfo.createConnState.requestUrl).toBeNull();
+      expect27(requestInfo.createConnState.requestMethod).toBeNull();
+      expect27(
         Object.keys(requestInfo.createConnState.requestHeaders)
       ).toHaveLength(0);
       await connection.dispose();
     });
-    test20("should capture request headers and method", async (c) => {
+    test27("should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-headers"],
@@ -3503,18 +4743,18 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect20(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect20(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
-        expect20(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
-        expect20(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
-        expect20(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+        expect27(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect27(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
+        expect27(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
+        expect27(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
+        expect27(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
           "object"
         );
-        expect20(requestInfo.createConnState.hasRequest).toBe(true);
-        expect20(requestInfo.createConnState.requestMethod).toBeTruthy();
-        expect20(requestInfo.createConnState.requestUrl).toBeTruthy();
-        expect20(requestInfo.createConnState.requestHeaders).toBeTruthy();
-        expect20(typeof requestInfo.createConnState.requestHeaders).toBe(
+        expect27(requestInfo.createConnState.hasRequest).toBe(true);
+        expect27(requestInfo.createConnState.requestMethod).toBeTruthy();
+        expect27(requestInfo.createConnState.requestUrl).toBeTruthy();
+        expect27(requestInfo.createConnState.requestHeaders).toBeTruthy();
+        expect27(typeof requestInfo.createConnState.requestHeaders).toBe(
           "object"
         );
       } else {
@@ -3526,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) {
-    describe23(`client type (${clientType})`, () => {
-      const encodings = ["bare", "cbor", "json"];
-      for (const encoding of encodings) {
-        describe23(`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);
-        });
-      }
-    });
-  }
+  describe29("Driver Tests", () => {
+    var _a;
+    const clientTypes = ((_a = driverTestConfigPartial.skip) == null ? void 0 : _a.inline) ? ["http"] : ["http", "inline"];
+    for (const clientType of clientTypes) {
+      describe29(`client type (${clientType})`, () => {
+        const encodings = ["bare", "cbor", "json"];
+        for (const encoding of encodings) {
+          describe29(`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;
@@ -3598,17 +4846,24 @@ async function createTestRuntime(registryPath, driverFactory) {
     const nodeWebSocket = createNodeWebSocket({ app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
     managerDriver.setGetUpgradeWebSocket(() => upgradeWebSocket);
-    const port = await getPort();
     const server = honoServe({
       fetch: router.fetch,
       hostname: "127.0.0.1",
-      port
+      port: 0
     });
+    if (!server.listening) {
+      await new Promise((resolve) => {
+        server.once("listening", () => resolve());
+      });
+    }
     invariant2(
       nodeWebSocket.injectWebSocket !== void 0,
       "should have injectWebSocket"
     );
     nodeWebSocket.injectWebSocket(server);
+    const address = server.address();
+    invariant2(address && typeof address !== "string", "missing server address");
+    const port = address.port;
     const serverEndpoint = `http://127.0.0.1:${port}`;
     logger().info({ msg: "test serer listening", port });
     const cleanup = async () => {