rivetkit 2.0.24 → 2.0.25-rc.2

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

@@ -1,30 +1,30 @@
 import {
   getPort
-} from "../chunk-MO5CB6MD.js";
+} from "../chunk-MPTF4FZG.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-MBBJUHSP.js";
+} from "../chunk-YUEDTVPT.js";
 import {
   configureInspectorAccessToken,
   createActorInspectorClient,
   createManagerInspectorClient
-} from "../chunk-YC7YPM2T.js";
+} from "../chunk-NEFTKDFY.js";
 import {
   createClient
-} from "../chunk-IMDS5T42.js";
+} from "../chunk-YGJY4IOG.js";
 import {
   ActorError,
   createClientWithDriver
-} from "../chunk-ZSPU5R4C.js";
-import "../chunk-DUJQWGYD.js";
+} from "../chunk-THRFFSBO.js";
+import "../chunk-F5WMZYRB.js";
 import {
   importWebSocket
-} from "../chunk-EIPANQMF.js";
+} from "../chunk-SSNBAXAL.js";
 import {
   ClientConfigSchema,
   RunnerConfigSchema
-} from "../chunk-OFOTPKAH.js";
+} from "../chunk-X6P24ETW.js";
 import {
   HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
@@ -35,15 +35,15 @@ import {
   WS_PROTOCOL_TARGET,
   WS_TEST_PROTOCOL_PATH,
   assertUnreachable
-} from "../chunk-I3XT7WOF.js";
+} from "../chunk-GOYBQC6L.js";
 import {
   getLogger,
   promiseWithResolvers
-} from "../chunk-BAIGSF64.js";
+} from "../chunk-AOC3ALJK.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-W6RDS6NW.js";
+} from "../chunk-LQOCWGP6.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
@@ -150,7 +150,9 @@ function createTestInlineClientDriver(endpoint, encoding) {
       const protocols = [];
       protocols.push(WS_PROTOCOL_STANDARD);
       protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-      protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
+      protocols.push(
+        `${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+      );
       protocols.push(`${WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
         `${WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
@@ -865,23 +867,176 @@ function runActorConnTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/actor-conn-state.ts
+// src/driver-test-suite/tests/actor-conn-hibernation.ts
 import { describe as describe3, expect as expect3, test as test3, vi as vi3 } from "vitest";
+
+// fixtures/driver-test-suite/hibernation.ts
+var HIBERNATION_SLEEP_TIMEOUT = 500;
+var hibernationActor = actor({
+  state: {
+    sleepCount: 0,
+    wakeCount: 0
+  },
+  createConnState: (c) => {
+    return {
+      count: 0,
+      connectCount: 0,
+      disconnectCount: 0
+    };
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onConnect: (c, conn) => {
+    conn.state.connectCount += 1;
+  },
+  onDisconnect: (c, conn) => {
+    conn.state.disconnectCount += 1;
+  },
+  actions: {
+    // Basic RPC that returns a simple value
+    ping: (c) => {
+      return "pong";
+    },
+    // Increment the connection's count
+    connIncrement: (c) => {
+      c.conn.state.count += 1;
+      return c.conn.state.count;
+    },
+    // Get the connection's count
+    getConnCount: (c) => {
+      return c.conn.state.count;
+    },
+    // Get the connection's lifecycle counts
+    getConnLifecycleCounts: (c) => {
+      return {
+        connectCount: c.conn.state.connectCount,
+        disconnectCount: c.conn.state.disconnectCount
+      };
+    },
+    // Get all connection IDs
+    getConnectionIds: (c) => {
+      return c.conns.entries().map((x) => x[0]).toArray();
+    },
+    // Get actor sleep/wake counts
+    getActorCounts: (c) => {
+      return {
+        sleepCount: c.state.sleepCount,
+        wakeCount: c.state.wakeCount
+      };
+    },
+    // Trigger sleep
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: HIBERNATION_SLEEP_TIMEOUT
+  }
+});
+
+// src/driver-test-suite/tests/actor-conn-hibernation.ts
+function runActorConnHibernationTests(driverTestConfig) {
+  var _a;
+  describe3.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
+    "Connection Hibernation",
+    () => {
+      test3("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");
+        await hibernatingActor.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        const ping2 = await hibernatingActor.ping();
+        expect3(ping2).toBe("pong");
+        await hibernatingActor.dispose();
+      });
+      test3("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);
+        const count2 = await hibernatingActor.connIncrement();
+        expect3(count2).toBe(2);
+        const initialLifecycle = await hibernatingActor.getConnLifecycleCounts();
+        expect3(initialLifecycle.connectCount).toBe(1);
+        expect3(initialLifecycle.disconnectCount).toBe(0);
+        const initialActorCounts = await hibernatingActor.getActorCounts();
+        expect3(initialActorCounts.wakeCount).toBe(1);
+        expect3(initialActorCounts.sleepCount).toBe(0);
+        await hibernatingActor.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        const count3 = await hibernatingActor.getConnCount();
+        expect3(count3).toBe(2);
+        const finalLifecycle = await hibernatingActor.getConnLifecycleCounts();
+        expect3(finalLifecycle.connectCount).toBe(1);
+        expect3(finalLifecycle.disconnectCount).toBe(0);
+        const finalActorCounts = await hibernatingActor.getActorCounts();
+        expect3(finalActorCounts.wakeCount).toBe(2);
+        expect3(finalActorCounts.sleepCount).toBe(1);
+        await hibernatingActor.dispose();
+      });
+      test3("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);
+        const conn1Id = connectionIds[0];
+        await conn1.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        await conn1.dispose();
+        await waitFor(driverTestConfig, 250);
+        const conn2 = client.hibernationActor.getOrCreate().connect();
+        await vi3.waitFor(
+          async () => {
+            const newConnectionIds = await conn2.getConnectionIds();
+            expect3(newConnectionIds.length).toBe(1);
+            expect3(newConnectionIds[0]).not.toBe(conn1Id);
+          },
+          {
+            timeout: 5e3,
+            interval: 100
+          }
+        );
+        const lifecycle = await conn2.getConnLifecycleCounts();
+        expect3(lifecycle.disconnectCount).toBe(0);
+        await conn2.dispose();
+      });
+    }
+  );
+}
+
+// src/driver-test-suite/tests/actor-conn-state.ts
+import { describe as describe4, expect as expect4, test as test4, vi as vi4 } from "vitest";
 function runActorConnStateTests(driverTestConfig) {
-  describe3("Actor Connection State Tests", () => {
-    describe3("Connection State Initialization", () => {
-      test3("should retrieve connection state", async (c) => {
+  describe4("Actor Connection State Tests", () => {
+    describe4("Connection State Initialization", () => {
+      test4("should retrieve connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connection = client.connStateActor.getOrCreate().connect();
         const connState = await connection.getConnectionState();
-        expect3(connState.id).toBeDefined();
-        expect3(connState.username).toBeDefined();
-        expect3(connState.role).toBeDefined();
-        expect3(connState.counter).toBeDefined();
-        expect3(connState.createdAt).toBeDefined();
+        expect4(connState.id).toBeDefined();
+        expect4(connState.username).toBeDefined();
+        expect4(connState.role).toBeDefined();
+        expect4(connState.counter).toBeDefined();
+        expect4(connState.createdAt).toBeDefined();
         await connection.dispose();
       });
-      test3("should initialize connection state with custom parameters", async (c) => {
+      test4("should initialize connection state with custom parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connection = client.connStateActor.getOrCreate([], {
           params: {
@@ -890,13 +1045,13 @@ function runActorConnStateTests(driverTestConfig) {
           }
         }).connect();
         const connState = await connection.getConnectionState();
-        expect3(connState.username).toBe("testuser");
-        expect3(connState.role).toBe("admin");
+        expect4(connState.username).toBe("testuser");
+        expect4(connState.role).toBe("admin");
         await connection.dispose();
       });
     });
-    describe3("Connection State Management", () => {
-      test3("should maintain unique state for each connection", async (c) => {
+    describe4("Connection State Management", () => {
+      test4("should maintain unique state for each connection", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn1 = client.connStateActor.getOrCreate([], {
           params: { username: "user1" }
@@ -908,14 +1063,14 @@ function runActorConnStateTests(driverTestConfig) {
         await conn2.incrementConnCounter(10);
         const state1 = await conn1.getConnectionState();
         const state2 = await conn2.getConnectionState();
-        expect3(state1.counter).toBe(5);
-        expect3(state2.counter).toBe(10);
-        expect3(state1.username).toBe("user1");
-        expect3(state2.username).toBe("user2");
+        expect4(state1.counter).toBe(5);
+        expect4(state2.counter).toBe(10);
+        expect4(state1.username).toBe("user1");
+        expect4(state2.username).toBe("user2");
         await conn1.dispose();
         await conn2.dispose();
       });
-      test3("should track connections in shared state", async (c) => {
+      test4("should track connections in shared state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -924,12 +1079,12 @@ function runActorConnStateTests(driverTestConfig) {
         await conn2.getConnectionState();
         const state1 = await conn1.getConnectionState();
         const connectionIds = await conn1.getConnectionIds();
-        expect3(connectionIds.length).toBeGreaterThanOrEqual(2);
-        expect3(connectionIds).toContain(state1.id);
+        expect4(connectionIds.length).toBeGreaterThanOrEqual(2);
+        expect4(connectionIds).toContain(state1.id);
         await conn1.dispose();
         await conn2.dispose();
       });
-      test3("should identify different connections in the same actor", async (c) => {
+      test4("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();
@@ -937,16 +1092,16 @@ function runActorConnStateTests(driverTestConfig) {
         await conn1.getConnectionState();
         await conn2.getConnectionState();
         const allStates = await conn1.getAllConnectionStates();
-        expect3(allStates.length).toBeGreaterThanOrEqual(2);
+        expect4(allStates.length).toBeGreaterThanOrEqual(2);
         const ids = allStates.map((state) => state.id);
         const uniqueIds = [...new Set(ids)];
-        expect3(uniqueIds.length).toBe(ids.length);
+        expect4(uniqueIds.length).toBe(ids.length);
         await conn1.dispose();
         await conn2.dispose();
       });
     });
-    describe3("Connection Lifecycle", () => {
-      test3("should track connection and disconnection events", async (c) => {
+    describe4("Connection Lifecycle", () => {
+      test4("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const debugHandle = client.connStateActor.getOrCreate(
           void 0,
@@ -956,21 +1111,21 @@ function runActorConnStateTests(driverTestConfig) {
         );
         const conn = client.connStateActor.getOrCreate().connect();
         const connState = await conn.getConnectionState();
-        await vi3.waitFor(async () => {
+        await vi4.waitFor(async () => {
           const connectionIds = await debugHandle.getConnectionIds();
-          expect3(connectionIds).toContain(connState.id);
+          expect4(connectionIds).toContain(connState.id);
         });
-        await vi3.waitFor(async () => {
+        await vi4.waitFor(async () => {
           const disconnects = await debugHandle.getDisconnectionCount();
-          expect3(disconnects).toBe(0);
+          expect4(disconnects).toBe(0);
         });
         await conn.dispose();
-        await vi3.waitFor(
+        await vi4.waitFor(
           async () => {
             console.log("disconnects before");
             const disconnects = await debugHandle.getDisconnectionCount();
             console.log("disconnects", disconnects);
-            expect3(disconnects).toBe(1);
+            expect4(disconnects).toBe(1);
           },
           // SSE takes a long time to disconnect on CF Workers
           {
@@ -979,18 +1134,18 @@ function runActorConnStateTests(driverTestConfig) {
           }
         );
         const newConn = client.connStateActor.getOrCreate().connect();
-        await vi3.waitFor(async () => {
+        await vi4.waitFor(async () => {
           const connectionIds = await debugHandle.getConnectionIds();
           console.log("conn ids", connectionIds);
-          expect3(connectionIds.length).toBe(1);
+          expect4(connectionIds.length).toBe(1);
         });
         await newConn.dispose();
-        await vi3.waitFor(
+        await vi4.waitFor(
           async () => {
             console.log("A");
             const disconnects = await debugHandle.getDisconnectionCount();
             console.log(`B ${disconnects}`);
-            expect3(disconnects).toBe(2);
+            expect4(disconnects).toBe(2);
           },
           // SSE takes a long time to disconnect on CF Workers
           {
@@ -999,25 +1154,25 @@ function runActorConnStateTests(driverTestConfig) {
           }
         );
       });
-      test3("should update connection state", async (c) => {
+      test4("should update connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn = client.connStateActor.getOrCreate().connect();
         const initialState = await conn.getConnectionState();
-        expect3(initialState.username).toBe("anonymous");
+        expect4(initialState.username).toBe("anonymous");
         const updatedState = await conn.updateConnection({
           username: "newname",
           role: "moderator"
         });
-        expect3(updatedState.username).toBe("newname");
-        expect3(updatedState.role).toBe("moderator");
+        expect4(updatedState.username).toBe("newname");
+        expect4(updatedState.role).toBe("moderator");
         const latestState = await conn.getConnectionState();
-        expect3(latestState.username).toBe("newname");
-        expect3(latestState.role).toBe("moderator");
+        expect4(latestState.username).toBe("newname");
+        expect4(latestState.role).toBe("moderator");
         await conn.dispose();
       });
     });
-    describe3("Connection Communication", () => {
-      test3("should send messages to specific connections", async (c) => {
+    describe4("Connection Communication", () => {
+      test4("should send messages to specific connections", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -1028,15 +1183,15 @@ function runActorConnStateTests(driverTestConfig) {
         conn2.on("directMessage", (data) => {
           receivedMessages.push(data);
         });
-        await vi3.waitFor(async () => {
+        await vi4.waitFor(async () => {
           const success = await conn1.sendToConnection(
             state2.id,
             "Hello from conn1"
           );
-          expect3(success).toBe(true);
-          expect3(receivedMessages.length).toBe(1);
-          expect3(receivedMessages[0].from).toBe(state1.id);
-          expect3(receivedMessages[0].message).toBe(
+          expect4(success).toBe(true);
+          expect4(receivedMessages.length).toBe(1);
+          expect4(receivedMessages[0].from).toBe(state1.id);
+          expect4(receivedMessages[0].message).toBe(
             "Hello from conn1"
           );
         });
@@ -1048,10 +1203,10 @@ function runActorConnStateTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-destroy.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 vi5 } from "vitest";
 function runActorDestroyTests(driverTestConfig) {
-  describe4("Actor Destroy Tests", () => {
-    test4("actor destroy clears state (without connect)", async (c) => {
+  describe5("Actor Destroy Tests", () => {
+    test5("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"]);
@@ -1059,33 +1214,33 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = client.destroyActor.getOrCreate([actorKey]);
       await destroyActor.setValue(42);
       const value = await destroyActor.getValue();
-      expect4(value).toBe(42);
+      expect5(value).toBe(42);
       const actorId = await destroyActor.resolve();
       await destroyActor.destroy();
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         let actorRunning = false;
         try {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect4(err.group).toBe("actor");
-          expect4(err.code).toBe("not_found");
+          expect5(err.group).toBe("actor");
+          expect5(err.code).toBe("not_found");
         }
-        expect4(actorRunning, "actor still running").toBeFalsy();
+        expect5(actorRunning, "actor still running").toBeFalsy();
       });
       let existsById = false;
       try {
         await client.destroyActor.getForId(actorId).getValue();
         existsById = true;
       } catch (err) {
-        expect4(err.group).toBe("actor");
-        expect4(err.code).toBe("not_found");
+        expect5(err.group).toBe("actor");
+        expect5(err.code).toBe("not_found");
       }
-      expect4(
+      expect5(
         existsById,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1094,10 +1249,10 @@ function runActorDestroyTests(driverTestConfig) {
         await client.destroyActor.get(["test-destroy-without-connect"]).resolve();
         existsByKey = true;
       } catch (err) {
-        expect4(err.group).toBe("actor");
-        expect4(err.code).toBe("not_found");
+        expect5(err.group).toBe("actor");
+        expect5(err.code).toBe("not_found");
       }
-      expect4(
+      expect5(
         existsByKey,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1105,9 +1260,9 @@ function runActorDestroyTests(driverTestConfig) {
         "test-destroy-without-connect"
       ]);
       const newValue = await newActor.getValue();
-      expect4(newValue).toBe(0);
+      expect5(newValue).toBe(0);
     });
-    test4("actor destroy clears state (with connect)", async (c) => {
+    test5("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"]);
@@ -1119,33 +1274,33 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = destroyActorHandle.connect();
       await destroyActor.setValue(99);
       const value = await destroyActor.getValue();
-      expect4(value).toBe(99);
+      expect5(value).toBe(99);
       await destroyActor.destroy();
       await destroyActor.dispose();
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         let actorRunning = false;
         try {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect4(err.group).toBe("actor");
-          expect4(err.code).toBe("not_found");
+          expect5(err.group).toBe("actor");
+          expect5(err.code).toBe("not_found");
         }
-        expect4(actorRunning, "actor still running").toBeFalsy();
+        expect5(actorRunning, "actor still running").toBeFalsy();
       });
       let existsById = false;
       try {
         await client.destroyActor.getForId(actorId).getValue();
         existsById = true;
       } catch (err) {
-        expect4(err.group).toBe("actor");
-        expect4(err.code).toBe("not_found");
+        expect5(err.group).toBe("actor");
+        expect5(err.code).toBe("not_found");
       }
-      expect4(
+      expect5(
         existsById,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1154,10 +1309,10 @@ function runActorDestroyTests(driverTestConfig) {
         await client.destroyActor.get(["test-destroy-with-connect"]).resolve();
         existsByKey = true;
       } catch (err) {
-        expect4(err.group).toBe("actor");
-        expect4(err.code).toBe("not_found");
+        expect5(err.group).toBe("actor");
+        expect5(err.code).toBe("not_found");
       }
-      expect4(
+      expect5(
         existsByKey,
         "actor should not exist after destroy"
       ).toBeFalsy();
@@ -1165,9 +1320,9 @@ function runActorDestroyTests(driverTestConfig) {
         "test-destroy-with-connect"
       ]);
       const newValue = await newActor.getValue();
-      expect4(newValue).toBe(0);
+      expect5(newValue).toBe(0);
     });
-    test4("actor destroy allows recreation via getOrCreate with resolve", async (c) => {
+    test5("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"]);
@@ -1175,30 +1330,30 @@ function runActorDestroyTests(driverTestConfig) {
       const destroyActor = client.destroyActor.getOrCreate([actorKey]);
       await destroyActor.setValue(123);
       const value = await destroyActor.getValue();
-      expect4(value).toBe(123);
+      expect5(value).toBe(123);
       const actorId = await destroyActor.resolve();
       await destroyActor.destroy();
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         let actorRunning = false;
         try {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect4(err.group).toBe("actor");
-          expect4(err.code).toBe("not_found");
+          expect5(err.group).toBe("actor");
+          expect5(err.code).toBe("not_found");
         }
-        expect4(actorRunning, "actor still running").toBeFalsy();
+        expect5(actorRunning, "actor still running").toBeFalsy();
       });
       const newHandle = client.destroyActor.getOrCreate([actorKey]);
       const newActorId = await newHandle.resolve();
       const newValue = await newHandle.getValue();
-      expect4(newValue).toBe(0);
+      expect5(newValue).toBe(0);
     });
-    test4("actor destroy allows recreation via create", async (c) => {
+    test5("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"]);
@@ -1206,44 +1361,44 @@ function runActorDestroyTests(driverTestConfig) {
       const initialHandle = await client.destroyActor.create([actorKey]);
       await initialHandle.setValue(456);
       const value = await initialHandle.getValue();
-      expect4(value).toBe(456);
+      expect5(value).toBe(456);
       const actorId = await initialHandle.resolve();
       await initialHandle.destroy();
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         const wasDestroyed = await observer.wasDestroyed(actorKey);
-        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+        expect5(wasDestroyed, "actor onDestroy not called").toBeTruthy();
       });
-      await vi4.waitFor(async () => {
+      await vi5.waitFor(async () => {
         let actorRunning = false;
         try {
           await client.destroyActor.getForId(actorId).getValue();
           actorRunning = true;
         } catch (err) {
-          expect4(err.group).toBe("actor");
-          expect4(err.code).toBe("not_found");
+          expect5(err.group).toBe("actor");
+          expect5(err.code).toBe("not_found");
         }
-        expect4(actorRunning, "actor still running").toBeFalsy();
+        expect5(actorRunning, "actor still running").toBeFalsy();
       });
       const newHandle = await client.destroyActor.create([actorKey]);
       const newActorId = await newHandle.resolve();
       const newValue = await newHandle.getValue();
-      expect4(newValue).toBe(0);
+      expect5(newValue).toBe(0);
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-driver.ts
-import { describe as describe8 } from "vitest";
+import { describe as describe9 } from "vitest";
 
 // src/driver-test-suite/tests/actor-schedule.ts
-import { describe as describe5, expect as expect5, test as test5 } from "vitest";
+import { describe as describe6, expect as expect6, test as test6 } from "vitest";
 function runActorScheduleTests(driverTestConfig) {
   var _a;
-  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+  describe6.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
     "Actor Schedule Tests",
     () => {
-      describe5("Scheduled Alarms", () => {
-        test5("executes c.schedule.at() with specific timestamp", async (c) => {
+      describe6("Scheduled Alarms", () => {
+        test6("executes c.schedule.at() with specific timestamp", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1254,10 +1409,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect5(lastRun).toBeGreaterThan(0);
-          expect5(scheduledCount).toBe(1);
+          expect6(lastRun).toBeGreaterThan(0);
+          expect6(scheduledCount).toBe(1);
         });
-        test5("executes c.schedule.after() with delay", async (c) => {
+        test6("executes c.schedule.after() with delay", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1267,10 +1422,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect5(lastRun).toBeGreaterThan(0);
-          expect5(scheduledCount).toBe(1);
+          expect6(lastRun).toBeGreaterThan(0);
+          expect6(scheduledCount).toBe(1);
         });
-        test5("multiple scheduled tasks execute in order", async (c) => {
+        test6("multiple scheduled tasks execute in order", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1282,13 +1437,13 @@ function runActorScheduleTests(driverTestConfig) {
           await scheduled.scheduleTaskAfterWithId("third", 1250);
           await waitFor(driverTestConfig, 500);
           const history1 = await scheduled.getTaskHistory();
-          expect5(history1).toEqual(["first"]);
+          expect6(history1).toEqual(["first"]);
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          expect5(history2).toEqual(["first", "second"]);
+          expect6(history2).toEqual(["first", "second"]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
-          expect5(history3).toEqual(["first", "second", "third"]);
+          expect6(history3).toEqual(["first", "second", "third"]);
         });
       });
     }
@@ -1296,7 +1451,7 @@ function runActorScheduleTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-sleep.ts
-import { describe as describe6, expect as expect6, test as test6 } from "vitest";
+import { describe as describe7, expect as expect7, test as test7 } from "vitest";
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 1e3;
@@ -1486,30 +1641,30 @@ var sleepWithNoSleepOption = actor({
 // src/driver-test-suite/tests/actor-sleep.ts
 function runActorSleepTests(driverTestConfig) {
   var _a;
-  describe6.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
-    test6("actor sleep persists state", async (c) => {
+  describe7.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    test7("actor sleep persists state", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await waitFor(driverTestConfig, 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("actor sleep persists state with connect", async (c) => {
+    test7("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();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
@@ -1517,108 +1672,108 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("actor automatically sleeps after timeout", async (c) => {
+    test7("actor automatically sleeps after timeout", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("actor automatically sleeps after timeout with connect", async (c) => {
+    test7("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();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("rpc calls keep actor awake", async (c) => {
+    test7("rpc calls keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("alarms keep actor awake", async (c) => {
+    test7("alarms keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT - 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
     });
-    test6("alarms wake actors", async (c) => {
+    test7("alarms wake actors", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT + 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("long running rpcs keep actor awake", async (c) => {
+    test7("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();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       const waitPromise = new Promise(
         (resolve) => sleepActor.once("waiting", resolve)
@@ -1630,19 +1785,19 @@ function runActorSleepTests(driverTestConfig) {
       await longRunningPromise;
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("active raw websockets keep actor awake", async (c) => {
+    test7("active raw websockets keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1650,8 +1805,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       const ws = await sleepActor.websocket();
       await new Promise((resolve, reject) => {
@@ -1676,17 +1831,17 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      expect6(counts.sleepCount).toBe(0);
-      expect6(counts.startCount).toBe(1);
+      expect7(counts.sleepCount).toBe(0);
+      expect7(counts.startCount).toBe(1);
       ws.close();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("active raw fetch requests keep actor awake", async (c) => {
+    test7("active raw fetch requests keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1694,8 +1849,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawHttp.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       const fetchDuration = SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
@@ -1703,67 +1858,67 @@ function runActorSleepTests(driverTestConfig) {
       );
       const response = await fetchPromise;
       const result = await response.json();
-      expect6(result.completed).toBe(true);
+      expect7(result.completed).toBe(true);
       {
         const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
-        expect6(requestCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
+        expect7(requestCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect7(sleepCount).toBe(1);
+        expect7(startCount).toBe(2);
       }
     });
-    test6("noSleep option disables sleeping", async (c) => {
+    test7("noSleep option disables sleeping", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect7(sleepCount).toBe(0);
+        expect7(startCount).toBe(1);
       }
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-state.ts
-import { describe as describe7, expect as expect7, test as test7 } from "vitest";
+import { describe as describe8, expect as expect8, test as test8 } from "vitest";
 function runActorStateTests(driverTestConfig) {
-  describe7("Actor State Tests", () => {
-    describe7("State Persistence", () => {
-      test7("persists state between actor instances", async (c) => {
+  describe8("Actor State Tests", () => {
+    describe8("State Persistence", () => {
+      test8("persists state between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterInstance = client.counter.getOrCreate();
         const initialCount = await counterInstance.increment(5);
-        expect7(initialCount).toBe(5);
+        expect8(initialCount).toBe(5);
         const sameInstance = client.counter.getOrCreate();
         const persistedCount = await sameInstance.increment(3);
-        expect7(persistedCount).toBe(8);
+        expect8(persistedCount).toBe(8);
       });
-      test7("restores state after actor disconnect/reconnect", async (c) => {
+      test8("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);
-        expect7(persistedCount).toBe(5);
+        expect8(persistedCount).toBe(5);
       });
-      test7("maintains separate state for different actors", async (c) => {
+      test8("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);
@@ -1771,8 +1926,8 @@ function runActorStateTests(driverTestConfig) {
         await counterB.increment(10);
         const countA = await counterA.increment(0);
         const countB = await counterB.increment(0);
-        expect7(countA).toBe(5);
-        expect7(countB).toBe(10);
+        expect8(countA).toBe(5);
+        expect8(countB).toBe(10);
       });
     });
   });
@@ -1780,7 +1935,7 @@ function runActorStateTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-driver.ts
 function runActorDriverTests(driverTestConfig) {
-  describe8("Actor Driver Tests", () => {
+  describe9("Actor Driver Tests", () => {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
     runActorSleepTests(driverTestConfig);
@@ -1788,82 +1943,82 @@ function runActorDriverTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-error-handling.ts
-import { describe as describe9, expect as expect8, test as test8 } from "vitest";
+import { describe as describe10, expect as expect9, test as test9 } from "vitest";
 function runActorErrorHandlingTests(driverTestConfig) {
-  describe9("Actor Error Handling Tests", () => {
-    describe9("UserError Handling", () => {
-      test8("should handle simple UserError with message", async (c) => {
+  describe10("Actor Error Handling Tests", () => {
+    describe10("UserError Handling", () => {
+      test9("should handle simple UserError with message", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwSimpleError();
-          expect8(true).toBe(false);
+          expect9(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toBe("Simple error message");
-          expect8(error.code).toBe("user_error");
-          expect8(error.metadata).toBeUndefined();
+          expect9(error.message).toBe("Simple error message");
+          expect9(error.code).toBe("user_error");
+          expect9(error.metadata).toBeUndefined();
         }
       });
-      test8("should handle detailed UserError with code and metadata", async (c) => {
+      test9("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();
-          expect8(true).toBe(false);
+          expect9(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toBe("Detailed error message");
-          expect8(error.code).toBe("detailed_error");
-          expect8(error.metadata).toBeDefined();
-          expect8(error.metadata.reason).toBe("test");
-          expect8(error.metadata.timestamp).toBeDefined();
+          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();
         }
       });
     });
-    describe9("Internal Error Handling", () => {
-      test8("should convert internal errors to safe format", async (c) => {
+    describe10("Internal Error Handling", () => {
+      test9("should convert internal errors to safe format", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwInternalError();
-          expect8(true).toBe(false);
+          expect9(true).toBe(false);
         } catch (error) {
-          expect8(error.code).toBe(INTERNAL_ERROR_CODE);
-          expect8(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+          expect9(error.code).toBe(INTERNAL_ERROR_CODE);
+          expect9(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
-    describe9.skip("Action Timeout", () => {
-      test8("should handle action timeouts with custom duration", async (c) => {
+    describe10.skip("Action Timeout", () => {
+      test9("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;
-          expect8(true).toBe(false);
+          expect9(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toMatch(/timed out/i);
+          expect9(error.message).toMatch(/timed out/i);
         }
       });
-      test8("should successfully run actions within timeout", async (c) => {
+      test9("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);
-        expect8(result).toBe("Completed after 200ms");
+        expect9(result).toBe("Completed after 200ms");
       });
-      test8("should respect different timeouts for different actors", async (c) => {
+      test9("should respect different timeouts for different actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         try {
           await client.customTimeoutActor.getOrCreate().slowAction();
-          expect8(true).toBe(false);
+          expect9(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toMatch(/timed out/i);
+          expect9(error.message).toMatch(/timed out/i);
         }
         const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
-        expect8(quickResult).toBe("Quick action completed");
+        expect9(quickResult).toBe("Quick action completed");
       });
     });
-    describe9("Error Recovery", () => {
-      test8("should continue working after errors", async (c) => {
+    describe10("Error Recovery", () => {
+      test9("should continue working after errors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
@@ -1871,27 +2026,27 @@ function runActorErrorHandlingTests(driverTestConfig) {
         } catch (error) {
         }
         const result = await handle.successfulAction();
-        expect8(result).toBe("success");
+        expect9(result).toBe("success");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-handle.ts
-import { describe as describe10, expect as expect9, test as test9 } from "vitest";
+import { describe as describe11, expect as expect10, test as test10 } from "vitest";
 function runActorHandleTests(driverTestConfig) {
-  describe10("Actor Handle Tests", () => {
-    describe10("Access Methods", () => {
-      test9("should use .get() to access a actor", async (c) => {
+  describe11("Actor Handle Tests", () => {
+    describe11("Access Methods", () => {
+      test10("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);
-        expect9(count).toBe(5);
+        expect10(count).toBe(5);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(5);
+        expect10(retrievedCount).toBe(5);
       });
-      test9("should use .getForId() to access a actor by ID", async (c) => {
+      test10("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"
@@ -1900,73 +2055,73 @@ function runActorHandleTests(driverTestConfig) {
         const actorId = await handle.resolve();
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect9(count).toBe(3);
+        expect10(count).toBe(3);
         const newCount = await idHandle.increment(4);
-        expect9(newCount).toBe(7);
+        expect10(newCount).toBe(7);
       });
-      test9("should use .getOrCreate() to access or create a actor", async (c) => {
+      test10("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);
-        expect9(count).toBe(7);
+        expect10(count).toBe(7);
         const sameHandle = client.counter.getOrCreate([
           "test-get-or-create-handle"
         ]);
         const retrievedCount = await sameHandle.getCount();
-        expect9(retrievedCount).toBe(7);
+        expect10(retrievedCount).toBe(7);
       });
-      test9("should use (await create()) to create and return a handle", async (c) => {
+      test10("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);
-        expect9(count).toBe(9);
+        expect10(count).toBe(9);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(9);
+        expect10(retrievedCount).toBe(9);
       });
-      test9("errors when calling create twice with the same key", async (c) => {
+      test10("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);
-          expect9.fail("did not error on duplicate create");
+          expect10.fail("did not error on duplicate create");
         } catch (err) {
-          expect9(err.group).toBe("actor");
-          expect9(err.code).toBe("duplicate_key");
+          expect10(err.group).toBe("actor");
+          expect10(err.code).toBe("duplicate_key");
         }
       });
-      test9(".get().resolve() errors for non-existent actor", async (c) => {
+      test10(".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();
-          expect9.fail(
+          expect10.fail(
             "did not error for get().resolve() on missing actor"
           );
         } catch (err) {
-          expect9(err.group).toBe("actor");
-          expect9(err.code).toBe("not_found");
+          expect10(err.group).toBe("actor");
+          expect10(err.code).toBe("not_found");
         }
       });
     });
-    describe10("Action Functionality", () => {
-      test9("should call actions directly on the handle", async (c) => {
+    describe11("Action Functionality", () => {
+      test10("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);
-        expect9(count1).toBe(3);
+        expect10(count1).toBe(3);
         const count2 = await handle.increment(5);
-        expect9(count2).toBe(8);
+        expect10(count2).toBe(8);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(8);
+        expect10(retrievedCount).toBe(8);
       });
-      test9("should handle independent handles to the same actor", async (c) => {
+      test10("should handle independent handles to the same actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle1 = client.counter.getOrCreate([
           "test-multiple-handles"
@@ -1974,82 +2129,82 @@ function runActorHandleTests(driverTestConfig) {
         const handle2 = client.counter.get(["test-multiple-handles"]);
         await handle1.increment(3);
         const count = await handle2.getCount();
-        expect9(count).toBe(3);
+        expect10(count).toBe(3);
         const finalCount = await handle2.increment(4);
-        expect9(finalCount).toBe(7);
+        expect10(finalCount).toBe(7);
         const checkCount = await handle1.getCount();
-        expect9(checkCount).toBe(7);
+        expect10(checkCount).toBe(7);
       });
-      test9("should resolve a actor's ID", async (c) => {
+      test10("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();
-        expect9(typeof actorId).toBe("string");
-        expect9(actorId).not.toBe("");
+        expect10(typeof actorId).toBe("string");
+        expect10(actorId).not.toBe("");
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect9(count).toBe(1);
+        expect10(count).toBe(1);
       });
     });
-    describe10("Lifecycle Hooks", () => {
-      test9("should trigger lifecycle hooks on actor creation", async (c) => {
+    describe11("Lifecycle Hooks", () => {
+      test10("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();
-        expect9(initialEvents).toContain("onWake");
+        expect10(initialEvents).toContain("onWake");
         const sameHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-handle"
         ]);
         const events = await sameHandle.getEvents();
-        expect9(events).toContain("onWake");
-        expect9(events.filter((e) => e === "onWake").length).toBe(1);
+        expect10(events).toContain("onWake");
+        expect10(events.filter((e) => e === "onWake").length).toBe(1);
       });
-      test9("should trigger lifecycle hooks for each Action call", async (c) => {
+      test10("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();
-        expect9(initialEvents).toContain("onWake");
-        expect9(initialEvents).not.toContain("onBeforeConnect");
-        expect9(initialEvents).not.toContain("onConnect");
-        expect9(initialEvents).not.toContain("onDisconnect");
+        expect10(initialEvents).toContain("onWake");
+        expect10(initialEvents).not.toContain("onBeforeConnect");
+        expect10(initialEvents).not.toContain("onConnect");
+        expect10(initialEvents).not.toContain("onDisconnect");
         const trackingHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle-action"],
           { params: { trackLifecycle: true } }
         );
         await trackingHandle.increment(5);
         const eventsAfterAction = await viewHandle.getEvents();
-        expect9(eventsAfterAction).toContain("onBeforeConnect");
-        expect9(eventsAfterAction).toContain("onConnect");
-        expect9(eventsAfterAction).toContain("onDisconnect");
-        expect9(
+        expect10(eventsAfterAction).toContain("onBeforeConnect");
+        expect10(eventsAfterAction).toContain("onConnect");
+        expect10(eventsAfterAction).toContain("onDisconnect");
+        expect10(
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        expect9(
+        expect10(
           eventsAfterAction.filter((e) => e === "onConnect").length
         ).toBe(1);
-        expect9(
+        expect10(
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
-        expect9(
+        expect10(
           eventsAfterSecondAction.filter(
             (e) => e === "onBeforeConnect"
           ).length
         ).toBe(2);
-        expect9(
+        expect10(
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
         ).toBe(2);
-        expect9(
+        expect10(
           eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
         ).toBe(2);
       });
-      test9("should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
+      test10("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"
@@ -2065,12 +2220,12 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle1.increment(5);
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
-        expect9(events.filter((e) => e === "onWake").length).toBe(1);
-        expect9(
+        expect10(events.filter((e) => e === "onWake").length).toBe(1);
+        expect10(
           events.filter((e) => e === "onBeforeConnect").length
         ).toBe(2);
-        expect9(events.filter((e) => e === "onConnect").length).toBe(2);
-        expect9(events.filter((e) => e === "onDisconnect").length).toBe(
+        expect10(events.filter((e) => e === "onConnect").length).toBe(2);
+        expect10(events.filter((e) => e === "onDisconnect").length).toBe(
           2
         );
       });
@@ -2078,159 +2233,6 @@ function runActorHandleTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/actor-conn-hibernation.ts
-import { describe as describe11, expect as expect10, test as test10, vi as vi5 } from "vitest";
-
-// fixtures/driver-test-suite/hibernation.ts
-var HIBERNATION_SLEEP_TIMEOUT = 500;
-var hibernationActor = actor({
-  state: {
-    sleepCount: 0,
-    wakeCount: 0
-  },
-  createConnState: (c) => {
-    return {
-      count: 0,
-      connectCount: 0,
-      disconnectCount: 0
-    };
-  },
-  onWake: (c) => {
-    c.state.wakeCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  onConnect: (c, conn) => {
-    conn.state.connectCount += 1;
-  },
-  onDisconnect: (c, conn) => {
-    conn.state.disconnectCount += 1;
-  },
-  actions: {
-    // Basic RPC that returns a simple value
-    ping: (c) => {
-      return "pong";
-    },
-    // Increment the connection's count
-    connIncrement: (c) => {
-      c.conn.state.count += 1;
-      return c.conn.state.count;
-    },
-    // Get the connection's count
-    getConnCount: (c) => {
-      return c.conn.state.count;
-    },
-    // Get the connection's lifecycle counts
-    getConnLifecycleCounts: (c) => {
-      return {
-        connectCount: c.conn.state.connectCount,
-        disconnectCount: c.conn.state.disconnectCount
-      };
-    },
-    // Get all connection IDs
-    getConnectionIds: (c) => {
-      return c.conns.entries().map((x) => x[0]).toArray();
-    },
-    // Get actor sleep/wake counts
-    getActorCounts: (c) => {
-      return {
-        sleepCount: c.state.sleepCount,
-        wakeCount: c.state.wakeCount
-      };
-    },
-    // Trigger sleep
-    triggerSleep: (c) => {
-      c.sleep();
-    }
-  },
-  options: {
-    sleepTimeout: HIBERNATION_SLEEP_TIMEOUT
-  }
-});
-
-// src/driver-test-suite/tests/actor-conn-hibernation.ts
-function runActorConnHibernationTests(driverTestConfig) {
-  var _a;
-  describe11.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
-    "Connection Hibernation",
-    () => {
-      test10("basic conn hibernation", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const hibernatingActor = client.hibernationActor.getOrCreate().connect();
-        const ping1 = await hibernatingActor.ping();
-        expect10(ping1).toBe("pong");
-        await hibernatingActor.triggerSleep();
-        await waitFor(
-          driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
-        );
-        const ping2 = await hibernatingActor.ping();
-        expect10(ping2).toBe("pong");
-        await hibernatingActor.dispose();
-      });
-      test10("conn state persists through hibernation", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const hibernatingActor = client.hibernationActor.getOrCreate().connect();
-        const count1 = await hibernatingActor.connIncrement();
-        expect10(count1).toBe(1);
-        const count2 = await hibernatingActor.connIncrement();
-        expect10(count2).toBe(2);
-        const initialLifecycle = await hibernatingActor.getConnLifecycleCounts();
-        expect10(initialLifecycle.connectCount).toBe(1);
-        expect10(initialLifecycle.disconnectCount).toBe(0);
-        const initialActorCounts = await hibernatingActor.getActorCounts();
-        expect10(initialActorCounts.wakeCount).toBe(1);
-        expect10(initialActorCounts.sleepCount).toBe(0);
-        await hibernatingActor.triggerSleep();
-        await waitFor(
-          driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
-        );
-        const count3 = await hibernatingActor.getConnCount();
-        expect10(count3).toBe(2);
-        const finalLifecycle = await hibernatingActor.getConnLifecycleCounts();
-        expect10(finalLifecycle.connectCount).toBe(1);
-        expect10(finalLifecycle.disconnectCount).toBe(0);
-        const finalActorCounts = await hibernatingActor.getActorCounts();
-        expect10(finalActorCounts.wakeCount).toBe(2);
-        expect10(finalActorCounts.sleepCount).toBe(1);
-        await hibernatingActor.dispose();
-      });
-      test10("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();
-        expect10(connectionIds.length).toBe(1);
-        const conn1Id = connectionIds[0];
-        await conn1.triggerSleep();
-        await waitFor(
-          driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
-        );
-        await conn1.dispose();
-        await waitFor(driverTestConfig, 250);
-        const conn2 = client.hibernationActor.getOrCreate().connect();
-        await vi5.waitFor(
-          async () => {
-            const newConnectionIds = await conn2.getConnectionIds();
-            expect10(newConnectionIds.length).toBe(1);
-            expect10(newConnectionIds[0]).not.toBe(conn1Id);
-          },
-          {
-            timeout: 5e3,
-            interval: 100
-          }
-        );
-        const lifecycle = await conn2.getConnLifecycleCounts();
-        expect10(lifecycle.disconnectCount).toBe(0);
-        await conn2.dispose();
-      });
-    }
-  );
-}
-
 // src/driver-test-suite/tests/actor-inline-client.ts
 import { describe as describe12, expect as expect11, test as test11 } from "vitest";
 function runActorInlineClientTests(driverTestConfig) {