rivetkit 2.0.24-rc.1 → 2.0.25-rc.1

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

@@ -1,56 +1,55 @@
 import {
   getPort
-} from "../chunk-BOMZS2TJ.js";
+} from "../chunk-BBVFDEYD.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-BYMKMOBS.js";
+} from "../chunk-FLOQ3UWM.js";
 import {
   configureInspectorAccessToken,
   createActorInspectorClient,
   createManagerInspectorClient
-} from "../chunk-FX7TWFQR.js";
+} from "../chunk-IDJK7ILQ.js";
 import {
   createClient
-} from "../chunk-YBHYXIP6.js";
+} from "../chunk-YVL6IRUM.js";
 import {
   ActorError,
   createClientWithDriver
-} from "../chunk-227FEWMB.js";
-import "../chunk-YBG6R7LX.js";
+} from "../chunk-HZYZ7JSF.js";
+import "../chunk-EDGN4OC7.js";
 import {
   importWebSocket
-} from "../chunk-CD33GT6Z.js";
+} from "../chunk-QIHBDXTO.js";
 import {
   ClientConfigSchema,
   RunnerConfigSchema
-} from "../chunk-S4UJG7ZE.js";
+} from "../chunk-7IBNNGQ2.js";
 import {
   HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
   WS_PROTOCOL_ACTOR,
   WS_PROTOCOL_CONN_PARAMS,
   WS_PROTOCOL_ENCODING,
-  WS_PROTOCOL_PATH,
+  WS_PROTOCOL_STANDARD,
   WS_PROTOCOL_TARGET,
-  WS_PROTOCOL_TRANSPORT,
+  WS_TEST_PROTOCOL_PATH,
   assertUnreachable
-} from "../chunk-BLK27ES3.js";
+} from "../chunk-6JN6W6G3.js";
 import {
   getLogger,
   promiseWithResolvers
-} from "../chunk-PLUN2NQT.js";
+} from "../chunk-NWBKMCWC.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-G64QUEDJ.js";
+} from "../chunk-W6RDS6NW.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket } from "@hono/node-ws";
-import { bundleRequire } from "bundle-require";
 import invariant from "invariant";
-import { describe as describe21 } from "vitest";
+import { describe as describe22 } from "vitest";
 
 // src/driver-test-suite/log.ts
 function logger() {
@@ -65,43 +64,26 @@ import { vi } from "vitest";
 
 // src/driver-test-suite/test-inline-client-driver.ts
 import * as cbor from "cbor-x";
-function createTestInlineClientDriver(endpoint, encoding, transport) {
+function createTestInlineClientDriver(endpoint, encoding) {
   return {
     getForId(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getForId",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getForId", [input]);
     },
     getWithKey(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getWithKey",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getWithKey", [input]);
     },
     getOrCreateWithKey(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getOrCreateWithKey",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getOrCreateWithKey", [
+        input
+      ]);
     },
     createActor(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "createActor",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "createActor", [
+        input
+      ]);
+    },
+    listActors(input) {
+      return makeInlineRequest(endpoint, encoding, "listActors", [input]);
     },
     async sendRequest(actorId, actorRequest) {
       var _a;
@@ -153,7 +135,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       }
       return response;
     },
-    async openWebSocket(path, actorId, encoding2, params, connId, connToken) {
+    async openWebSocket(path, actorId, encoding2, params) {
       const WebSocket2 = await importWebSocket();
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
@@ -165,20 +147,24 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
-      logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
       const protocols = [];
+      protocols.push(WS_PROTOCOL_STANDARD);
       protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-      protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+      protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
       protocols.push(`${WS_PROTOCOL_ENCODING}${encoding2}`);
-      protocols.push(`${WS_PROTOCOL_TRANSPORT}${transport}`);
       protocols.push(
-        `${WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
           `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
+      logger().debug({
+        msg: "connecting to websocket",
+        url: finalWsUrl,
+        protocols
+      });
       const ws = new WebSocket2(finalWsUrl, protocols);
       return ws;
     },
@@ -204,7 +190,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 	return makeInlineRequest<Response>(
     // 		endpoint,
     // 		encoding,
-    // 		transport,
     // 		"action",
     // 		[undefined, actorQuery, encoding, params, name, args],
     // 	);
@@ -219,7 +204,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 	return makeInlineRequest<string>(
     // 		endpoint,
     // 		encodingKind,
-    // 		transport,
     // 		"resolveActorId",
     // 		[undefined, actorQuery, encodingKind, params],
     // 	);
@@ -341,7 +325,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 		actorId,
     // 		encoding,
     // 		connectionId,
-    // 		transport,
     // 	});
     //
     // 	const result = await fetch(
@@ -353,7 +336,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 			},
     // 			body: JSON.stringify({
     // 				encoding,
-    // 				transport,
     // 				method: "sendHttpMessage",
     // 				args: [
     // 					undefined,
@@ -424,7 +406,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 			if (errorData.error) {
     // 				// Handle both error formats:
     // 				// 1. { error: { code, message, metadata } } - structured format
-    // 				// 2. { error: "message" } - simple string format (from custom onFetch handlers)
+    // 				// 2. { error: "message" } - simple string format (from custom onRequest handlers)
     // 				if (typeof errorData.error === "object") {
     // 					throw new ClientActorError(
     // 						errorData.error.code,
@@ -433,7 +415,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 					);
     // 				}
     // 				// For simple string errors, just return the response as-is
-    // 				// This allows custom onFetch handlers to return their own error formats
+    // 				// This allows custom onRequest handlers to return their own error formats
     // 			}
     // 		} catch (e) {
     // 			// If it's not our error format, just return the response as-is
@@ -510,11 +492,10 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // },
   };
 }
-async function makeInlineRequest(endpoint, encoding, transport, method, args) {
+async function makeInlineRequest(endpoint, encoding, method, args) {
   logger().debug({
     msg: "sending inline request",
     encoding,
-    transport,
     method,
     args
   });
@@ -525,7 +506,6 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
     },
     body: cbor.encode({
       encoding,
-      transport,
       method,
       args
     }),
@@ -562,26 +542,22 @@ async function setupDriverTest(c, driverTestConfig) {
     vi.setSystemTime(FAKE_TIME);
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
-  c.onTestFinished(cleanup);
+  c.onTestFinished(() => {
+    logger().info("cleaning up test");
+    cleanup();
+  });
   let client;
   if (driverTestConfig.clientType === "http") {
     client = createClient({
       endpoint,
       namespace,
       runnerName,
-      transport: driverTestConfig.transport,
       encoding: driverTestConfig.encoding
     });
   } else if (driverTestConfig.clientType === "inline") {
-    const transport = driverTestConfig.transport ?? "websocket";
     const encoding = driverTestConfig.encoding ?? "bare";
-    const managerDriver = createTestInlineClientDriver(
-      endpoint,
-      encoding,
-      transport
-    );
+    const managerDriver = createTestInlineClientDriver(endpoint, encoding);
     const runConfig = RunnerConfigSchema.parse({
-      transport,
       encoding
     });
     client = createClientWithDriver(managerDriver, runConfig);
@@ -838,9 +814,7 @@ function runActorConnTests(driverTestConfig) {
       });
     });
     describe2("Lifecycle Hooks", () => {
-      test2.skipIf(
-        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
-      )("should trigger lifecycle hooks", async (c) => {
+      test2("should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -851,7 +825,7 @@ function runActorConnTests(driverTestConfig) {
         const connection = connHandle.connect();
         const events = await connection.getEvents();
         expect2(events).toEqual([
-          "onStart",
+          "onWake",
           "onBeforeConnect",
           "onConnect"
         ]);
@@ -865,18 +839,18 @@ function runActorConnTests(driverTestConfig) {
             expect2(finalEvents).toBeOneOf([
               // Still active
               [
-                "onStart",
+                "onWake",
                 "onBeforeConnect",
                 "onConnect",
                 "onDisconnect"
               ],
               // Went to sleep and woke back up
               [
-                "onStart",
+                "onWake",
                 "onBeforeConnect",
                 "onConnect",
                 "onDisconnect",
-                "onStart"
+                "onWake"
               ]
             ]);
           },
@@ -972,9 +946,7 @@ function runActorConnStateTests(driverTestConfig) {
       });
     });
     describe3("Connection Lifecycle", () => {
-      test3.skipIf(
-        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
-      )("should track connection and disconnection events", async (c) => {
+      test3("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const debugHandle = client.connStateActor.getOrCreate(
           void 0,
@@ -1075,18 +1047,203 @@ 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";
+function runActorDestroyTests(driverTestConfig) {
+  describe4("Actor Destroy Tests", () => {
+    test4("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"]);
+      await observer.reset();
+      const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+      await destroyActor.setValue(42);
+      const value = await destroyActor.getValue();
+      expect4(value).toBe(42);
+      const actorId = await destroyActor.resolve();
+      await destroyActor.destroy();
+      await vi4.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await vi4.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");
+        }
+        expect4(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");
+      }
+      expect4(
+        existsById,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      let existsByKey = false;
+      try {
+        await client.destroyActor.get(["test-destroy-without-connect"]).resolve();
+        existsByKey = true;
+      } catch (err) {
+        expect4(err.group).toBe("actor");
+        expect4(err.code).toBe("not_found");
+      }
+      expect4(
+        existsByKey,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      const newActor = client.destroyActor.getOrCreate([
+        "test-destroy-without-connect"
+      ]);
+      const newValue = await newActor.getValue();
+      expect4(newValue).toBe(0);
+    });
+    test4("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"]);
+      await observer.reset();
+      const destroyActorHandle = client.destroyActor.getOrCreate([
+        actorKey
+      ]);
+      const actorId = await destroyActorHandle.resolve();
+      const destroyActor = destroyActorHandle.connect();
+      await destroyActor.setValue(99);
+      const value = await destroyActor.getValue();
+      expect4(value).toBe(99);
+      await destroyActor.destroy();
+      await destroyActor.dispose();
+      await vi4.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await vi4.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");
+        }
+        expect4(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");
+      }
+      expect4(
+        existsById,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      let existsByKey = false;
+      try {
+        await client.destroyActor.get(["test-destroy-with-connect"]).resolve();
+        existsByKey = true;
+      } catch (err) {
+        expect4(err.group).toBe("actor");
+        expect4(err.code).toBe("not_found");
+      }
+      expect4(
+        existsByKey,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      const newActor = client.destroyActor.getOrCreate([
+        "test-destroy-with-connect"
+      ]);
+      const newValue = await newActor.getValue();
+      expect4(newValue).toBe(0);
+    });
+    test4("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"]);
+      await observer.reset();
+      const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+      await destroyActor.setValue(123);
+      const value = await destroyActor.getValue();
+      expect4(value).toBe(123);
+      const actorId = await destroyActor.resolve();
+      await destroyActor.destroy();
+      await vi4.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await vi4.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");
+        }
+        expect4(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);
+    });
+    test4("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"]);
+      await observer.reset();
+      const initialHandle = await client.destroyActor.create([actorKey]);
+      await initialHandle.setValue(456);
+      const value = await initialHandle.getValue();
+      expect4(value).toBe(456);
+      const actorId = await initialHandle.resolve();
+      await initialHandle.destroy();
+      await vi4.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        expect4(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await vi4.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");
+        }
+        expect4(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);
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-driver.ts
-import { describe as describe7 } from "vitest";
+import { describe as describe8 } from "vitest";
 
 // src/driver-test-suite/tests/actor-schedule.ts
-import { describe as describe4, expect as expect4, test as test4 } from "vitest";
+import { describe as describe5, expect as expect5, test as test5 } from "vitest";
 function runActorScheduleTests(driverTestConfig) {
   var _a;
-  describe4.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
     "Actor Schedule Tests",
     () => {
-      describe4("Scheduled Alarms", () => {
-        test4("executes c.schedule.at() with specific timestamp", async (c) => {
+      describe5("Scheduled Alarms", () => {
+        test5("executes c.schedule.at() with specific timestamp", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1097,10 +1254,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect4(lastRun).toBeGreaterThan(0);
-          expect4(scheduledCount).toBe(1);
+          expect5(lastRun).toBeGreaterThan(0);
+          expect5(scheduledCount).toBe(1);
         });
-        test4("executes c.schedule.after() with delay", async (c) => {
+        test5("executes c.schedule.after() with delay", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1110,10 +1267,10 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 500);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect4(lastRun).toBeGreaterThan(0);
-          expect4(scheduledCount).toBe(1);
+          expect5(lastRun).toBeGreaterThan(0);
+          expect5(scheduledCount).toBe(1);
         });
-        test4("multiple scheduled tasks execute in order", async (c) => {
+        test5("multiple scheduled tasks execute in order", async (c) => {
           const { client } = await setupDriverTest(
             c,
             driverTestConfig
@@ -1125,13 +1282,13 @@ function runActorScheduleTests(driverTestConfig) {
           await scheduled.scheduleTaskAfterWithId("third", 1250);
           await waitFor(driverTestConfig, 500);
           const history1 = await scheduled.getTaskHistory();
-          expect4(history1).toEqual(["first"]);
+          expect5(history1).toEqual(["first"]);
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          expect4(history2).toEqual(["first", "second"]);
+          expect5(history2).toEqual(["first", "second"]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
-          expect4(history3).toEqual(["first", "second", "third"]);
+          expect5(history3).toEqual(["first", "second", "third"]);
         });
       });
     }
@@ -1139,16 +1296,16 @@ function runActorScheduleTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-sleep.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";
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 1e3;
 var sleep = actor({
   state: { startCount: 0, sleepCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1175,10 +1332,10 @@ var sleep = actor({
 var sleepWithLongRpc = actor({
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1206,13 +1363,13 @@ var sleepWithLongRpc = actor({
 });
 var sleepWithRawHttp = actor({
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
-  onFetch: async (c, request) => {
+  onRequest: async (c, request) => {
     c.state.requestCount += 1;
     const url = new URL(request.url);
     if (url.pathname === "/long-request") {
@@ -1243,13 +1400,13 @@ var sleepWithRawHttp = actor({
 });
 var sleepWithRawWebSocket = actor({
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
-  onWebSocket: (c, websocket, opts) => {
+  onWebSocket: (c, websocket) => {
     c.state.connectionCount += 1;
     c.log.info({
       msg: "websocket connected",
@@ -1306,10 +1463,10 @@ var sleepWithRawWebSocket = actor({
 });
 var sleepWithNoSleepOption = actor({
   state: { startCount: 0, sleepCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1329,30 +1486,30 @@ var sleepWithNoSleepOption = actor({
 // src/driver-test-suite/tests/actor-sleep.ts
 function runActorSleepTests(driverTestConfig) {
   var _a;
-  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
-    test5("actor sleep persists state", async (c) => {
+  describe6.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    test6("actor sleep persists state", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await waitFor(driverTestConfig, 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("actor sleep persists state with connect", async (c) => {
+    test6("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();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
@@ -1360,108 +1517,108 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("actor automatically sleeps after timeout", async (c) => {
+    test6("actor automatically sleeps after timeout", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("actor automatically sleeps after timeout with connect", async (c) => {
+    test6("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();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("rpc calls keep actor awake", async (c) => {
+    test6("rpc calls keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("alarms keep actor awake", async (c) => {
+    test6("alarms keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT - 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
     });
-    test5("alarms wake actors", async (c) => {
+    test6("alarms wake actors", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.setAlarm(SLEEP_TIMEOUT + 250);
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("long running rpcs keep actor awake", async (c) => {
+    test6("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();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       const waitPromise = new Promise(
         (resolve) => sleepActor.once("waiting", resolve)
@@ -1473,19 +1630,19 @@ function runActorSleepTests(driverTestConfig) {
       await longRunningPromise;
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await sleepActor.dispose();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("active raw websockets keep actor awake", async (c) => {
+    test6("active raw websockets keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1493,8 +1650,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       const ws = await sleepActor.websocket();
       await new Promise((resolve, reject) => {
@@ -1519,17 +1676,17 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      expect5(counts.sleepCount).toBe(0);
-      expect5(counts.startCount).toBe(1);
+      expect6(counts.sleepCount).toBe(0);
+      expect6(counts.startCount).toBe(1);
       ws.close();
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("active raw fetch requests keep actor awake", async (c) => {
+    test6("active raw fetch requests keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1537,8 +1694,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawHttp.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       const fetchDuration = SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
@@ -1546,67 +1703,67 @@ function runActorSleepTests(driverTestConfig) {
       );
       const response = await fetchPromise;
       const result = await response.json();
-      expect5(result.completed).toBe(true);
+      expect6(result.completed).toBe(true);
       {
         const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
-        expect5(requestCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+        expect6(requestCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(1);
-        expect5(startCount).toBe(2);
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
       }
     });
-    test5("noSleep option disables sleeping", async (c) => {
+    test6("noSleep option disables sleeping", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect5(sleepCount).toBe(0);
-        expect5(startCount).toBe(1);
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
       }
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-state.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";
 function runActorStateTests(driverTestConfig) {
-  describe6("Actor State Tests", () => {
-    describe6("State Persistence", () => {
-      test6("persists state between actor instances", async (c) => {
+  describe7("Actor State Tests", () => {
+    describe7("State Persistence", () => {
+      test7("persists state between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterInstance = client.counter.getOrCreate();
         const initialCount = await counterInstance.increment(5);
-        expect6(initialCount).toBe(5);
+        expect7(initialCount).toBe(5);
         const sameInstance = client.counter.getOrCreate();
         const persistedCount = await sameInstance.increment(3);
-        expect6(persistedCount).toBe(8);
+        expect7(persistedCount).toBe(8);
       });
-      test6("restores state after actor disconnect/reconnect", async (c) => {
+      test7("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);
-        expect6(persistedCount).toBe(5);
+        expect7(persistedCount).toBe(5);
       });
-      test6("maintains separate state for different actors", async (c) => {
+      test7("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);
@@ -1614,8 +1771,8 @@ function runActorStateTests(driverTestConfig) {
         await counterB.increment(10);
         const countA = await counterA.increment(0);
         const countB = await counterB.increment(0);
-        expect6(countA).toBe(5);
-        expect6(countB).toBe(10);
+        expect7(countA).toBe(5);
+        expect7(countB).toBe(10);
       });
     });
   });
@@ -1623,94 +1780,90 @@ function runActorStateTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-driver.ts
 function runActorDriverTests(driverTestConfig) {
-  describe7("Actor Driver Tests", () => {
+  describe8("Actor Driver Tests", () => {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
-  });
-}
-function runActorDriverTestsWithTransport(driverTestConfig) {
-  describe7("Actor Driver Tests", () => {
     runActorSleepTests(driverTestConfig);
   });
 }
 
 // src/driver-test-suite/tests/actor-error-handling.ts
-import { describe as describe8, expect as expect7, test as test7 } from "vitest";
+import { describe as describe9, expect as expect8, test as test8 } from "vitest";
 function runActorErrorHandlingTests(driverTestConfig) {
-  describe8("Actor Error Handling Tests", () => {
-    describe8("UserError Handling", () => {
-      test7("should handle simple UserError with message", async (c) => {
+  describe9("Actor Error Handling Tests", () => {
+    describe9("UserError Handling", () => {
+      test8("should handle simple UserError with message", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwSimpleError();
-          expect7(true).toBe(false);
+          expect8(true).toBe(false);
         } catch (error) {
-          expect7(error.message).toBe("Simple error message");
-          expect7(error.code).toBe("user_error");
-          expect7(error.metadata).toBeUndefined();
+          expect8(error.message).toBe("Simple error message");
+          expect8(error.code).toBe("user_error");
+          expect8(error.metadata).toBeUndefined();
         }
       });
-      test7("should handle detailed UserError with code and metadata", async (c) => {
+      test8("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();
-          expect7(true).toBe(false);
+          expect8(true).toBe(false);
         } catch (error) {
-          expect7(error.message).toBe("Detailed error message");
-          expect7(error.code).toBe("detailed_error");
-          expect7(error.metadata).toBeDefined();
-          expect7(error.metadata.reason).toBe("test");
-          expect7(error.metadata.timestamp).toBeDefined();
+          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();
         }
       });
     });
-    describe8("Internal Error Handling", () => {
-      test7("should convert internal errors to safe format", async (c) => {
+    describe9("Internal Error Handling", () => {
+      test8("should convert internal errors to safe format", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
           await handle.throwInternalError();
-          expect7(true).toBe(false);
+          expect8(true).toBe(false);
         } catch (error) {
-          expect7(error.code).toBe(INTERNAL_ERROR_CODE);
-          expect7(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+          expect8(error.code).toBe(INTERNAL_ERROR_CODE);
+          expect8(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
-    describe8.skip("Action Timeout", () => {
-      test7("should handle action timeouts with custom duration", async (c) => {
+    describe9.skip("Action Timeout", () => {
+      test8("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;
-          expect7(true).toBe(false);
+          expect8(true).toBe(false);
         } catch (error) {
-          expect7(error.message).toMatch(/timed out/i);
+          expect8(error.message).toMatch(/timed out/i);
         }
       });
-      test7("should successfully run actions within timeout", async (c) => {
+      test8("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);
-        expect7(result).toBe("Completed after 200ms");
+        expect8(result).toBe("Completed after 200ms");
       });
-      test7("should respect different timeouts for different actors", async (c) => {
+      test8("should respect different timeouts for different actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         try {
           await client.customTimeoutActor.getOrCreate().slowAction();
-          expect7(true).toBe(false);
+          expect8(true).toBe(false);
         } catch (error) {
-          expect7(error.message).toMatch(/timed out/i);
+          expect8(error.message).toMatch(/timed out/i);
         }
         const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
-        expect7(quickResult).toBe("Quick action completed");
+        expect8(quickResult).toBe("Quick action completed");
       });
     });
-    describe8("Error Recovery", () => {
-      test7("should continue working after errors", async (c) => {
+    describe9("Error Recovery", () => {
+      test8("should continue working after errors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
@@ -1718,27 +1871,27 @@ function runActorErrorHandlingTests(driverTestConfig) {
         } catch (error) {
         }
         const result = await handle.successfulAction();
-        expect7(result).toBe("success");
+        expect8(result).toBe("success");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-handle.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 runActorHandleTests(driverTestConfig) {
-  describe9("Actor Handle Tests", () => {
-    describe9("Access Methods", () => {
-      test8("should use .get() to access a actor", async (c) => {
+  describe10("Actor Handle Tests", () => {
+    describe10("Access Methods", () => {
+      test9("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);
-        expect8(count).toBe(5);
+        expect9(count).toBe(5);
         const retrievedCount = await handle.getCount();
-        expect8(retrievedCount).toBe(5);
+        expect9(retrievedCount).toBe(5);
       });
-      test8("should use .getForId() to access a actor by ID", async (c) => {
+      test9("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"
@@ -1747,73 +1900,73 @@ function runActorHandleTests(driverTestConfig) {
         const actorId = await handle.resolve();
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect8(count).toBe(3);
+        expect9(count).toBe(3);
         const newCount = await idHandle.increment(4);
-        expect8(newCount).toBe(7);
+        expect9(newCount).toBe(7);
       });
-      test8("should use .getOrCreate() to access or create a actor", async (c) => {
+      test9("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);
-        expect8(count).toBe(7);
+        expect9(count).toBe(7);
         const sameHandle = client.counter.getOrCreate([
           "test-get-or-create-handle"
         ]);
         const retrievedCount = await sameHandle.getCount();
-        expect8(retrievedCount).toBe(7);
+        expect9(retrievedCount).toBe(7);
       });
-      test8("should use (await create()) to create and return a handle", async (c) => {
+      test9("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);
-        expect8(count).toBe(9);
+        expect9(count).toBe(9);
         const retrievedCount = await handle.getCount();
-        expect8(retrievedCount).toBe(9);
+        expect9(retrievedCount).toBe(9);
       });
-      test8("errors when calling create twice with the same key", async (c) => {
+      test9("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);
-          expect8.fail("did not error on duplicate create");
+          expect9.fail("did not error on duplicate create");
         } catch (err) {
-          expect8(err.group).toBe("actor");
-          expect8(err.code).toBe("already_exists");
+          expect9(err.group).toBe("actor");
+          expect9(err.code).toBe("duplicate_key");
         }
       });
-      test8(".get().resolve() errors for non-existent actor", async (c) => {
+      test9(".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();
-          expect8.fail(
+          expect9.fail(
             "did not error for get().resolve() on missing actor"
           );
         } catch (err) {
-          expect8(err.group).toBe("actor");
-          expect8(err.code).toBe("not_found");
+          expect9(err.group).toBe("actor");
+          expect9(err.code).toBe("not_found");
         }
       });
     });
-    describe9("Action Functionality", () => {
-      test8("should call actions directly on the handle", async (c) => {
+    describe10("Action Functionality", () => {
+      test9("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);
-        expect8(count1).toBe(3);
+        expect9(count1).toBe(3);
         const count2 = await handle.increment(5);
-        expect8(count2).toBe(8);
+        expect9(count2).toBe(8);
         const retrievedCount = await handle.getCount();
-        expect8(retrievedCount).toBe(8);
+        expect9(retrievedCount).toBe(8);
       });
-      test8("should handle independent handles to the same actor", async (c) => {
+      test9("should handle independent handles to the same actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle1 = client.counter.getOrCreate([
           "test-multiple-handles"
@@ -1821,82 +1974,82 @@ function runActorHandleTests(driverTestConfig) {
         const handle2 = client.counter.get(["test-multiple-handles"]);
         await handle1.increment(3);
         const count = await handle2.getCount();
-        expect8(count).toBe(3);
+        expect9(count).toBe(3);
         const finalCount = await handle2.increment(4);
-        expect8(finalCount).toBe(7);
+        expect9(finalCount).toBe(7);
         const checkCount = await handle1.getCount();
-        expect8(checkCount).toBe(7);
+        expect9(checkCount).toBe(7);
       });
-      test8("should resolve a actor's ID", async (c) => {
+      test9("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();
-        expect8(typeof actorId).toBe("string");
-        expect8(actorId).not.toBe("");
+        expect9(typeof actorId).toBe("string");
+        expect9(actorId).not.toBe("");
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect8(count).toBe(1);
+        expect9(count).toBe(1);
       });
     });
-    describe9("Lifecycle Hooks", () => {
-      test8("should trigger lifecycle hooks on actor creation", async (c) => {
+    describe10("Lifecycle Hooks", () => {
+      test9("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();
-        expect8(initialEvents).toContain("onStart");
+        expect9(initialEvents).toContain("onWake");
         const sameHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-handle"
         ]);
         const events = await sameHandle.getEvents();
-        expect8(events).toContain("onStart");
-        expect8(events.filter((e) => e === "onStart").length).toBe(1);
+        expect9(events).toContain("onWake");
+        expect9(events.filter((e) => e === "onWake").length).toBe(1);
       });
-      test8("should trigger lifecycle hooks for each Action call", async (c) => {
+      test9("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();
-        expect8(initialEvents).toContain("onStart");
-        expect8(initialEvents).not.toContain("onBeforeConnect");
-        expect8(initialEvents).not.toContain("onConnect");
-        expect8(initialEvents).not.toContain("onDisconnect");
+        expect9(initialEvents).toContain("onWake");
+        expect9(initialEvents).not.toContain("onBeforeConnect");
+        expect9(initialEvents).not.toContain("onConnect");
+        expect9(initialEvents).not.toContain("onDisconnect");
         const trackingHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle-action"],
           { params: { trackLifecycle: true } }
         );
         await trackingHandle.increment(5);
         const eventsAfterAction = await viewHandle.getEvents();
-        expect8(eventsAfterAction).toContain("onBeforeConnect");
-        expect8(eventsAfterAction).toContain("onConnect");
-        expect8(eventsAfterAction).toContain("onDisconnect");
-        expect8(
+        expect9(eventsAfterAction).toContain("onBeforeConnect");
+        expect9(eventsAfterAction).toContain("onConnect");
+        expect9(eventsAfterAction).toContain("onDisconnect");
+        expect9(
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        expect8(
+        expect9(
           eventsAfterAction.filter((e) => e === "onConnect").length
         ).toBe(1);
-        expect8(
+        expect9(
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
-        expect8(
+        expect9(
           eventsAfterSecondAction.filter(
             (e) => e === "onBeforeConnect"
           ).length
         ).toBe(2);
-        expect8(
+        expect9(
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
         ).toBe(2);
-        expect8(
+        expect9(
           eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
         ).toBe(2);
       });
-      test8("should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
+      test9("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"
@@ -1912,12 +2065,12 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle1.increment(5);
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
-        expect8(events.filter((e) => e === "onStart").length).toBe(1);
-        expect8(
+        expect9(events.filter((e) => e === "onWake").length).toBe(1);
+        expect9(
           events.filter((e) => e === "onBeforeConnect").length
         ).toBe(2);
-        expect8(events.filter((e) => e === "onConnect").length).toBe(2);
-        expect8(events.filter((e) => e === "onDisconnect").length).toBe(
+        expect9(events.filter((e) => e === "onConnect").length).toBe(2);
+        expect9(events.filter((e) => e === "onDisconnect").length).toBe(
           2
         );
       });
@@ -1925,28 +2078,181 @@ 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 describe10, expect as expect9, test as test9 } from "vitest";
+import { describe as describe12, expect as expect11, test as test11 } from "vitest";
 function runActorInlineClientTests(driverTestConfig) {
-  describe10("Actor Inline Client Tests", () => {
-    describe10("Stateless Client Calls", () => {
-      test9("should make stateless calls to other actors", async (c) => {
+  describe12("Actor Inline Client Tests", () => {
+    describe12("Stateless Client Calls", () => {
+      test11("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);
-        expect9(result).toBe(5);
+        expect11(result).toBe(5);
         const counterState = await inlineClientHandle.getCounterState();
-        expect9(counterState).toBe(5);
+        expect11(counterState).toBe(5);
         const messages = await inlineClientHandle.getMessages();
-        expect9(messages).toHaveLength(2);
-        expect9(messages[0]).toContain(
+        expect11(messages).toHaveLength(2);
+        expect11(messages[0]).toContain(
           "Called counter.increment(5), result: 5"
         );
-        expect9(messages[1]).toContain("Got counter state: 5");
+        expect11(messages[1]).toContain("Got counter state: 5");
       });
-      test9("should handle multiple stateless calls", async (c) => {
+      test11("should handle multiple stateless calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-multi"]
@@ -1955,58 +2261,58 @@ function runActorInlineClientTests(driverTestConfig) {
         const result1 = await inlineClientHandle.callCounterIncrement(3);
         const result2 = await inlineClientHandle.callCounterIncrement(7);
         const finalState = await inlineClientHandle.getCounterState();
-        expect9(result1).toBe(3);
-        expect9(result2).toBe(10);
-        expect9(finalState).toBe(10);
+        expect11(result1).toBe(3);
+        expect11(result2).toBe(10);
+        expect11(finalState).toBe(10);
         const messages = await inlineClientHandle.getMessages();
-        expect9(messages).toHaveLength(3);
-        expect9(messages[0]).toContain(
+        expect11(messages).toHaveLength(3);
+        expect11(messages[0]).toContain(
           "Called counter.increment(3), result: 3"
         );
-        expect9(messages[1]).toContain(
+        expect11(messages[1]).toContain(
           "Called counter.increment(7), result: 10"
         );
-        expect9(messages[2]).toContain("Got counter state: 10");
+        expect11(messages[2]).toContain("Got counter state: 10");
       });
     });
-    describe10("Stateful Client Calls", () => {
-      test9("should connect to other actors and receive events", async (c) => {
+    describe12("Stateful Client Calls", () => {
+      test11("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);
-        expect9(result.result1).toBe(4);
-        expect9(result.result2).toBe(12);
-        expect9(result.events).toEqual([4, 12]);
+        expect11(result.result1).toBe(4);
+        expect11(result.result2).toBe(12);
+        expect11(result.events).toEqual([4, 12]);
         const messages = await inlineClientHandle.getMessages();
-        expect9(messages).toHaveLength(1);
-        expect9(messages[0]).toContain(
+        expect11(messages).toHaveLength(1);
+        expect11(messages[0]).toContain(
           "Connected to counter, incremented by 4 and 8"
         );
-        expect9(messages[0]).toContain("results: 4, 12");
-        expect9(messages[0]).toContain("events: [4,12]");
+        expect11(messages[0]).toContain("results: 4, 12");
+        expect11(messages[0]).toContain("events: [4,12]");
       });
-      test9("should handle stateful connection independently", async (c) => {
+      test11("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);
-        expect9(result.result1).toBe(2);
-        expect9(result.result2).toBe(6);
-        expect9(result.events).toEqual([2, 6]);
+        expect11(result.result1).toBe(2);
+        expect11(result.result2).toBe(6);
+        expect11(result.events).toEqual([2, 6]);
         const messages = await inlineClientHandle.getMessages();
-        expect9(messages).toHaveLength(1);
-        expect9(messages[0]).toContain(
+        expect11(messages).toHaveLength(1);
+        expect11(messages[0]).toContain(
           "Connected to counter, incremented by 2 and 4"
         );
       });
     });
-    describe10("Mixed Client Usage", () => {
-      test9("should handle both stateless and stateful calls", async (c) => {
+    describe12("Mixed Client Usage", () => {
+      test11("should handle both stateless and stateful calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate(
           ["inline-client-mixed"]
@@ -2014,17 +2320,17 @@ function runActorInlineClientTests(driverTestConfig) {
         await inlineClientHandle.clearMessages();
         await inlineClientHandle.callCounterIncrement(1);
         const statelessResult = await inlineClientHandle.getCounterState();
-        expect9(statelessResult).toBe(1);
+        expect11(statelessResult).toBe(1);
         const statefulResult = await inlineClientHandle.connectToCounterAndIncrement(3);
-        expect9(statefulResult.result1).toBe(3);
-        expect9(statefulResult.result2).toBe(9);
+        expect11(statefulResult.result1).toBe(3);
+        expect11(statefulResult.result2).toBe(9);
         const messages = await inlineClientHandle.getMessages();
-        expect9(messages).toHaveLength(3);
-        expect9(messages[0]).toContain(
+        expect11(messages).toHaveLength(3);
+        expect11(messages[0]).toContain(
           "Called counter.increment(1), result: 1"
         );
-        expect9(messages[1]).toContain("Got counter state: 1");
-        expect9(messages[2]).toContain(
+        expect11(messages[1]).toContain("Got counter state: 1");
+        expect11(messages[2]).toContain(
           "Connected to counter, incremented by 3 and 6"
         );
       });
@@ -2033,11 +2339,11 @@ function runActorInlineClientTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-inspector.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 runActorInspectorTests(driverTestConfig) {
-  describe11.skip("Actor Inspector Tests", () => {
-    describe11("Manager Inspector", () => {
-      test10("should respond to ping", async (c) => {
+  describe13.skip("Actor Inspector Tests", () => {
+    describe13("Manager Inspector", () => {
+      test12("should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(
           `${endpoint}/inspect`,
@@ -2048,11 +2354,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.ping.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual({ message: "pong" });
+        expect12(data).toEqual({ message: "pong" });
       });
-      test10("should get actors with pagination", async (c) => {
+      test12("should get actors with pagination", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2070,16 +2376,16 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "1" }
         });
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({ key: ["test-actor-1"] })
+        expect12(data).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({ key: ["test-actor-1"] })
           ])
         );
-        expect10(data.length).toBe(1);
+        expect12(data.length).toBe(1);
       });
-      test10("should get all actors with pagination", async (c) => {
+      test12("should get all actors with pagination", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2099,22 +2405,22 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "5" }
         });
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({
-              id: expect10.any(String),
+        expect12(data).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({
+              id: expect12.any(String),
               key: actorKey1
             }),
-            expect10.objectContaining({
-              id: expect10.any(String),
+            expect12.objectContaining({
+              id: expect12.any(String),
               key: actorKey2
             })
           ])
         );
       });
-      test10("should handle invalid limit parameter", async (c) => {
+      test12("should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(
           `${endpoint}/inspect`,
@@ -2127,9 +2433,9 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "0" }
         });
-        expect10(response.status).toBe(400);
+        expect12(response.status).toBe(400);
       });
-      test10("should create a new actor", async (c) => {
+      test12("should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(
           `${endpoint}/inspect`,
@@ -2146,17 +2452,17 @@ function runActorInspectorTests(driverTestConfig) {
             input: {}
           }
         });
-        expect10(response.status).toBe(201);
+        expect12(response.status).toBe(201);
         const data = await response.json();
-        expect10(data).toEqual(
-          expect10.objectContaining({
-            id: expect10.any(String),
+        expect12(data).toEqual(
+          expect12.objectContaining({
+            id: expect12.any(String),
             name: "default",
             key: ["test-create-actor"]
           })
         );
       });
-      test10("should get builds", async (c) => {
+      test12("should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(
           `${endpoint}/inspect`,
@@ -2167,15 +2473,15 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.builds.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({ name: expect10.any(String) })
+        expect12(data).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({ name: expect12.any(String) })
           ])
         );
       });
-      test10("should get actor by id", async (c) => {
+      test12("should get actor by id", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2193,11 +2499,11 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actor[":id"].$get({
           param: { id: actorId }
         });
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toHaveProperty("id", actorId);
+        expect12(data).toHaveProperty("id", actorId);
       });
-      test10("should return 404 for non-existent actor", async (c) => {
+      test12("should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(
           `${endpoint}/inspect`,
@@ -2210,11 +2516,11 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actor[":id"].$get({
           param: { id: "non-existent-id" }
         });
-        expect10(response.status).toBe(404);
+        expect12(response.status).toBe(404);
         const data = await response.json();
-        expect10(data).toEqual({ error: "Actor not found" });
+        expect12(data).toEqual({ error: "Actor not found" });
       });
-      test10("should get bootstrap data", async (c) => {
+      test12("should get bootstrap data", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2230,11 +2536,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.bootstrap.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data.actors).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({
+        expect12(data.actors).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({
               key: ["test-bootstrap"],
               name: "counter"
             })
@@ -2242,8 +2548,8 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
     });
-    describe11("Actor Inspector", () => {
-      test10("should handle actor not found", async (c) => {
+    describe13("Actor Inspector", () => {
+      test12("should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
         const http = createActorInspectorClient(
@@ -2258,9 +2564,9 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.ping.$get();
-        expect10(response.ok).toBe(false);
+        expect12(response.ok).toBe(false);
       });
-      test10("should respond to ping", async (c) => {
+      test12("should respond to ping", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2279,11 +2585,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.ping.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual({ message: "pong" });
+        expect12(data).toEqual({ message: "pong" });
       });
-      test10("should get actor state", async (c) => {
+      test12("should get actor state", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2303,16 +2609,16 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.state.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual({
+        expect12(data).toEqual({
           enabled: true,
-          state: expect10.objectContaining({
+          state: expect12.objectContaining({
             count: 5
           })
         });
       });
-      test10("should update actor state with replace", async (c) => {
+      test12("should update actor state with replace", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2337,14 +2643,14 @@ function runActorInspectorTests(driverTestConfig) {
             replace: { count: 10 }
           }
         });
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual({
+        expect12(data).toEqual({
           enabled: true,
           state: { count: 10 }
         });
       });
-      test10("should update actor state with patch", async (c) => {
+      test12("should update actor state with patch", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2376,16 +2682,16 @@ function runActorInspectorTests(driverTestConfig) {
             ]
           }
         });
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual({
+        expect12(data).toEqual({
           enabled: true,
-          state: expect10.objectContaining({
+          state: expect12.objectContaining({
             count: 7
           })
         });
       });
-      test10("should get actor connections", async (c) => {
+      test12("should get actor connections", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2408,17 +2714,17 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.connections.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data.connections).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({
-              id: expect10.any(String)
+        expect12(data.connections).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({
+              id: expect12.any(String)
             })
           ])
         );
       });
-      test10("should get actor events", async (c) => {
+      test12("should get actor events", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2439,18 +2745,18 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.events.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data.events).toEqual(
-          expect10.arrayContaining([
-            expect10.objectContaining({
+        expect12(data.events).toEqual(
+          expect12.arrayContaining([
+            expect12.objectContaining({
               type: "broadcast",
-              id: expect10.any(String)
+              id: expect12.any(String)
             })
           ])
         );
       });
-      test10("should clear actor events", async (c) => {
+      test12("should clear actor events", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2474,21 +2780,21 @@ function runActorInspectorTests(driverTestConfig) {
         );
         {
           const response2 = await http.events.$get();
-          expect10(response2.status).toBe(200);
+          expect12(response2.status).toBe(200);
           const data = await response2.json();
-          expect10(data.events).toEqual(
-            expect10.arrayContaining([
-              expect10.objectContaining({
+          expect12(data.events).toEqual(
+            expect12.arrayContaining([
+              expect12.objectContaining({
                 type: "broadcast",
-                id: expect10.any(String)
+                id: expect12.any(String)
               })
             ])
           );
         }
         const response = await http.events.clear.$post();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
       });
-      test10("should get actor rpcs", async (c) => {
+      test12("should get actor rpcs", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2507,15 +2813,15 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.rpcs.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toEqual(
-          expect10.objectContaining({
-            rpcs: expect10.arrayContaining(["increment", "getCount"])
+        expect12(data).toEqual(
+          expect12.objectContaining({
+            rpcs: expect12.arrayContaining(["increment", "getCount"])
           })
         );
       });
-      test10.skip("should get actor database info", async (c) => {
+      test12.skip("should get actor database info", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2534,18 +2840,18 @@ function runActorInspectorTests(driverTestConfig) {
           }
         );
         const response = await http.db.$get();
-        expect10(response.status).toBe(200);
+        expect12(response.status).toBe(200);
         const data = await response.json();
-        expect10(data).toHaveProperty("enabled");
-        expect10(typeof data.enabled).toBe("boolean");
+        expect12(data).toHaveProperty("enabled");
+        expect12(typeof data.enabled).toBe("boolean");
         if (data.enabled) {
-          expect10(data).toHaveProperty("db");
-          expect10(Array.isArray(data.db)).toBe(true);
+          expect12(data).toHaveProperty("db");
+          expect12(Array.isArray(data.db)).toBe(true);
         } else {
-          expect10(data.db).toBe(null);
+          expect12(data.db).toBe(null);
         }
       });
-      test10.skip("should execute database query when database is enabled", async (c) => {
+      test12.skip("should execute database query when database is enabled", async (c) => {
         const { client, endpoint } = await setupDriverTest(
           c,
           driverTestConfig
@@ -2572,9 +2878,9 @@ function runActorInspectorTests(driverTestConfig) {
               params: []
             }
           });
-          expect10(queryResponse.status).toBe(200);
+          expect12(queryResponse.status).toBe(200);
           const queryData = await queryResponse.json();
-          expect10(queryData).toHaveProperty("result");
+          expect12(queryData).toHaveProperty("result");
         } else {
           const queryResponse = await http.db.$post({
             json: {
@@ -2582,9 +2888,9 @@ function runActorInspectorTests(driverTestConfig) {
               params: []
             }
           });
-          expect10(queryResponse.status).toBe(200);
+          expect12(queryResponse.status).toBe(200);
           const queryData = await queryResponse.json();
-          expect10(queryData).toEqual({ enabled: false });
+          expect12(queryData).toEqual({ enabled: false });
         }
       });
     });
@@ -2592,25 +2898,25 @@ function runActorInspectorTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-metadata.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 runActorMetadataTests(driverTestConfig) {
-  describe12("Actor Metadata Tests", () => {
-    describe12("Actor Name", () => {
-      test11("should provide access to actor name", async (c) => {
+  describe14("Actor Metadata Tests", () => {
+    describe14("Actor Name", () => {
+      test13("should provide access to actor name", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         const actorName = await handle.getActorName();
-        expect11(actorName).toBe("metadataActor");
+        expect13(actorName).toBe("metadataActor");
       });
-      test11("should preserve actor name in state during onStart", async (c) => {
+      test13("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();
-        expect11(storedName).toBe("metadataActor");
+        expect13(storedName).toBe("metadataActor");
       });
     });
-    describe12("Actor Tags", () => {
-      test11("should provide access to tags", async (c) => {
+    describe14("Actor Tags", () => {
+      test13("should provide access to tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2618,12 +2924,12 @@ function runActorMetadataTests(driverTestConfig) {
           purpose: "metadata-test"
         });
         const tags = await handle.getTags();
-        expect11(tags).toHaveProperty("env");
-        expect11(tags.env).toBe("test");
-        expect11(tags).toHaveProperty("purpose");
-        expect11(tags.purpose).toBe("metadata-test");
+        expect13(tags).toHaveProperty("env");
+        expect13(tags.env).toBe("test");
+        expect13(tags).toHaveProperty("purpose");
+        expect13(tags.purpose).toBe("metadata-test");
       });
-      test11("should allow accessing individual tags", async (c) => {
+      test13("should allow accessing individual tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2633,217 +2939,110 @@ function runActorMetadataTests(driverTestConfig) {
         const category = await handle.getTag("category");
         const version = await handle.getTag("version");
         const nonexistent = await handle.getTag("nonexistent");
-        expect11(category).toBe("test-actor");
-        expect11(version).toBe("1.0");
-        expect11(nonexistent).toBeNull();
+        expect13(category).toBe("test-actor");
+        expect13(version).toBe("1.0");
+        expect13(nonexistent).toBeNull();
       });
     });
-    describe12("Metadata Structure", () => {
-      test11("should provide complete metadata object", async (c) => {
+    describe14("Metadata Structure", () => {
+      test13("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();
-        expect11(metadata).toHaveProperty("name");
-        expect11(metadata.name).toBe("metadataActor");
-        expect11(metadata).toHaveProperty("tags");
-        expect11(metadata.tags).toHaveProperty("type");
-        expect11(metadata.tags.type).toBe("metadata-test");
-        expect11(metadata).toHaveProperty("region");
-        expect11(metadata.region).toBe("us-west-1");
+        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");
       });
     });
-    describe12("Region Information", () => {
-      test11("should retrieve region information", async (c) => {
+    describe14("Region Information", () => {
+      test13("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();
-        expect11(region).toBe("eu-central-1");
+        expect13(region).toBe("eu-central-1");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-onstatechange.ts
-import { describe as describe13, expect as expect12, test as test12 } from "vitest";
+import { describe as describe15, expect as expect14, test as test14 } from "vitest";
 function runActorOnStateChangeTests(driverTestConfig) {
-  describe13("Actor onStateChange Tests", () => {
-    test12("triggers onStateChange when state is modified", async (c) => {
+  describe15("Actor onStateChange Tests", () => {
+    test14("triggers onStateChange when state is modified", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.onStateChangeActor.getOrCreate();
       await actor2.setValue(10);
       const changeCount = await actor2.getChangeCount();
-      expect12(changeCount).toBe(1);
+      expect14(changeCount).toBe(1);
     });
-    test12("triggers onChange multiple times for multiple state changes", async (c) => {
+    test14("triggers onChange multiple times for multiple state changes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.onStateChangeActor.getOrCreate();
       await actor2.incrementMultiple(3);
       const changeCount = await actor2.getChangeCount();
-      expect12(changeCount).toBe(3);
+      expect14(changeCount).toBe(3);
     });
-    test12("does NOT trigger onChange for read-only actions", async (c) => {
+    test14("does NOT trigger onChange for read-only actions", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.onStateChangeActor.getOrCreate();
       await actor2.setValue(5);
       const value = await actor2.getValue();
-      expect12(value).toBe(5);
+      expect14(value).toBe(5);
       const changeCount = await actor2.getChangeCount();
-      expect12(changeCount).toBe(1);
+      expect14(changeCount).toBe(1);
     });
-    test12("does NOT trigger onChange for computed values", async (c) => {
+    test14("does NOT trigger onChange for computed values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.onStateChangeActor.getOrCreate();
       await actor2.setValue(3);
       {
         const changeCount = await actor2.getChangeCount();
-        expect12(changeCount).toBe(1);
+        expect14(changeCount).toBe(1);
       }
       const doubled = await actor2.getDoubled();
-      expect12(doubled).toBe(6);
+      expect14(doubled).toBe(6);
       {
         const changeCount = await actor2.getChangeCount();
-        expect12(changeCount).toBe(1);
+        expect14(changeCount).toBe(1);
       }
     });
-    test12("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
+    test14("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.onStateChangeActor.getOrCreate();
       const connection = await actor2.connect();
       const value = await connection.getValue();
-      expect12(value).toBe(0);
+      expect14(value).toBe(0);
       await connection.dispose();
       const changeCount = await actor2.getChangeCount();
-      expect12(changeCount).toBe(0);
+      expect14(changeCount).toBe(0);
     });
   });
 }
 
-// src/driver-test-suite/tests/actor-reconnect.ts
-import { describe as describe14, expect as expect13, test as test13, vi as vi4 } from "vitest";
-function runActorReconnectTests(driverTestConfig) {
-  describe14("Actor Reconnection Tests", () => {
-    test13("should reconnect and preserve connection state after non-clean disconnect", async (c) => {
-      const { client, endpoint } = await setupDriverTest(
-        c,
-        driverTestConfig
-      );
-      const handle = client.counterConn.getOrCreate(["test-reconnect"]);
-      const connection = handle.connect();
-      await connection.increment(5);
-      const connCount1 = await connection.getConnectionCount();
-      expect13(connCount1).toBe(1);
-      const connRaw = connection;
-      await forceUncleanDisconnect(
-        endpoint,
-        connRaw.actorId,
-        connRaw.connectionId
-      );
-      await vi4.waitFor(
-        async () => {
-          const countAfterReconnect = await connection.getCount();
-          expect13(countAfterReconnect).toBe(5);
-        },
-        { timeout: 5e3, interval: 100 }
-      );
-      const connCount2 = await connection.getConnectionCount();
-      expect13(connCount2).toBe(1);
-      const newCount = await connection.getCount();
-      expect13(newCount).toBe(5);
-      await connection.dispose();
-    });
-    test13("should not preserve connection state after clean disconnect", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counterConn.getOrCreate([
-        "test-clean-disconnect"
-      ]);
-      const connection = handle.connect();
-      await connection.increment(10);
-      const connCount1 = await connection.getConnectionCount();
-      expect13(connCount1).toBe(1);
-      await connection.dispose();
-      await vi4.waitFor(
-        async () => {
-          const handle2 = client.counterConn.get([
-            "test-clean-disconnect"
-          ]);
-          const connCount = await handle2.getConnectionCount();
-          expect13(connCount).toBe(1);
-        },
-        { timeout: 5e3 }
-      );
-      const connection2 = handle.connect();
-      const countNewConnection = await connection2.getCount();
-      expect13(countNewConnection).toBe(0);
-      const connCount3 = await connection2.getConnectionCount();
-      expect13(connCount3).toBe(1);
-      await connection2.dispose();
-    });
-    test13("should handle multiple non-clean disconnects and reconnects", async (c) => {
-      const { client, endpoint } = await setupDriverTest(
-        c,
-        driverTestConfig
-      );
-      const handle = client.counterConn.getOrCreate([
-        "test-multiple-reconnect"
-      ]);
-      const connection = handle.connect();
-      await connection.setCount(100);
-      for (let i = 0; i < 3; i++) {
-        await connection.increment(1);
-        const connRaw = connection;
-        await forceUncleanDisconnect(
-          endpoint,
-          connRaw.actorId,
-          connRaw.connectionId
-        );
-        await vi4.waitFor(
-          async () => {
-            const countAfter = await connection.getCount();
-            expect13(countAfter).toBe(101 + i);
-          },
-          { timeout: 5e3 }
-        );
-        const connCount = await connection.getConnectionCount();
-        expect13(connCount).toBe(1);
-      }
-      const finalCount = await connection.getCount();
-      expect13(finalCount).toBe(103);
-      await connection.dispose();
-    });
-  });
-}
-async function forceUncleanDisconnect(endpoint, actorId, connId) {
-  const response = await fetch(
-    `${endpoint}/.test/force-disconnect?actor=${actorId}&conn=${connId}`,
-    {
-      method: "POST"
-    }
-  );
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Failed to force disconnect: ${text}`);
-  }
-}
-
 // src/driver-test-suite/tests/actor-vars.ts
-import { describe as describe15, expect as expect14, test as test14 } from "vitest";
+import { describe as describe16, expect as expect15, test as test15 } from "vitest";
 function runActorVarsTests(driverTestConfig) {
-  describe15("Actor Variables", () => {
-    describe15("Static vars", () => {
-      test14("should provide access to static vars", async (c) => {
+  describe16("Actor Variables", () => {
+    describe16("Static vars", () => {
+      test15("should provide access to static vars", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.staticVarActor.getOrCreate();
         const result = await instance.getVars();
-        expect14(result).toEqual({ counter: 42, name: "test-actor" });
+        expect15(result).toEqual({ counter: 42, name: "test-actor" });
         const name = await instance.getName();
-        expect14(name).toBe("test-actor");
+        expect15(name).toBe("test-actor");
       });
     });
-    describe15("Deep cloning of static vars", () => {
-      test14("should deep clone static vars between actor instances", async (c) => {
+    describe16("Deep cloning of static vars", () => {
+      test15("should deep clone static vars between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.nestedVarActor.getOrCreate([
           "instance1"
@@ -2852,100 +3051,100 @@ function runActorVarsTests(driverTestConfig) {
           "instance2"
         ]);
         const modifiedVars = await instance1.modifyNested();
-        expect14(modifiedVars.nested.value).toBe("modified");
-        expect14(modifiedVars.nested.array).toContain(4);
-        expect14(modifiedVars.nested.obj.key).toBe("new-value");
+        expect15(modifiedVars.nested.value).toBe("modified");
+        expect15(modifiedVars.nested.array).toContain(4);
+        expect15(modifiedVars.nested.obj.key).toBe("new-value");
         const instance2Vars = await instance2.getVars();
-        expect14(instance2Vars.nested.value).toBe("original");
-        expect14(instance2Vars.nested.array).toEqual([1, 2, 3]);
-        expect14(instance2Vars.nested.obj.key).toBe("value");
+        expect15(instance2Vars.nested.value).toBe("original");
+        expect15(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect15(instance2Vars.nested.obj.key).toBe("value");
       });
     });
-    describe15("createVars", () => {
-      test14("should support dynamic vars creation", async (c) => {
+    describe16("createVars", () => {
+      test15("should support dynamic vars creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.dynamicVarActor.getOrCreate();
         const vars = await instance.getVars();
-        expect14(vars).toHaveProperty("random");
-        expect14(vars).toHaveProperty("computed");
-        expect14(typeof vars.random).toBe("number");
-        expect14(typeof vars.computed).toBe("string");
-        expect14(vars.computed).toMatch(/^Actor-\d+$/);
+        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+$/);
       });
-      test14("should create different vars for different instances", async (c) => {
+      test15("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();
-        expect14(vars1.id).not.toBe(vars2.id);
+        expect15(vars1.id).not.toBe(vars2.id);
       });
     });
-    describe15("Driver Context", () => {
-      test14("should provide access to driver context", async (c) => {
+    describe16("Driver Context", () => {
+      test15("should provide access to driver context", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.driverCtxActor.getOrCreate();
         const vars = await instance.getVars();
-        expect14(vars).toHaveProperty("hasDriverCtx");
+        expect15(vars).toHaveProperty("hasDriverCtx");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/manager-driver.ts
-import { describe as describe16, expect as expect15, test as test15 } from "vitest";
+import { describe as describe17, expect as expect16, test as test16 } from "vitest";
 function runManagerDriverTests(driverTestConfig) {
-  describe16("Manager Driver Tests", () => {
-    describe16("Client Connection Methods", () => {
-      test15("connect() - finds or creates a actor", async (c) => {
+  describe17("Manager Driver Tests", () => {
+    describe17("Client Connection Methods", () => {
+      test16("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);
-        expect15(count).toBe(5);
+        expect16(count).toBe(5);
         const counterB = client.counter.getOrCreate([
           "counter-b",
           "testing"
         ]);
         await counterB.increment(10);
         const countB = await counterB.increment(0);
-        expect15(countB).toBe(10);
+        expect16(countB).toBe(10);
       });
-      test15("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+      test16("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);
-          expect15.fail("did not error on duplicate create");
+          expect16.fail("did not error on duplicate create");
         } catch (err) {
-          expect15(err.group).toBe("actor");
-          expect15(err.code).toBe("already_exists");
+          expect16(err.group).toBe("actor");
+          expect16(err.code).toBe("duplicate_key");
         }
         const count = await counter.increment(0);
-        expect15(count).toBe(5);
+        expect16(count).toBe(5);
       });
     });
-    describe16("Connection Options", () => {
-      test15("get without create prevents actor creation", async (c) => {
+    describe17("Connection Options", () => {
+      test16("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();
-          expect15.fail("did not error for get");
+          expect16.fail("did not error for get");
         } catch (err) {
-          expect15(err.group).toBe("actor");
-          expect15(err.code).toBe("not_found");
+          expect16(err.group).toBe("actor");
+          expect16(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);
-        expect15(count).toBe(3);
+        expect16(count).toBe(3);
       });
-      test15("connection params are passed to actors", async (c) => {
+      test16("connection params are passed to actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counter = client.counter.getOrCreate(void 0, {
           params: {
@@ -2956,20 +3155,20 @@ function runManagerDriverTests(driverTestConfig) {
         });
         await counter.increment(1);
         const count = await counter.increment(0);
-        expect15(count).toBe(1);
+        expect16(count).toBe(1);
       });
     });
-    describe16("Actor Creation & Retrieval", () => {
-      test15("creates and retrieves actors by ID", async (c) => {
+    describe17("Actor Creation & Retrieval", () => {
+      test16("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);
-        expect15(count).toBe(10);
+        expect16(count).toBe(10);
       });
-      test15("passes input to actor during creation", async (c) => {
+      test16("passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const testInput = {
           name: "test-actor",
@@ -2980,17 +3179,17 @@ function runManagerDriverTests(driverTestConfig) {
           input: testInput
         });
         const inputs = await actor2.getInputs();
-        expect15(inputs.initialInput).toEqual(testInput);
-        expect15(inputs.onCreateInput).toEqual(testInput);
+        expect16(inputs.initialInput).toEqual(testInput);
+        expect16(inputs.onCreateInput).toEqual(testInput);
       });
-      test15("input is undefined when not provided", async (c) => {
+      test16("input is undefined when not provided", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const actor2 = await client.inputActor.create();
         const inputs = await actor2.getInputs();
-        expect15(inputs.initialInput).toBeUndefined();
-        expect15(inputs.onCreateInput).toBeUndefined();
+        expect16(inputs.initialInput).toBeUndefined();
+        expect16(inputs.onCreateInput).toBeUndefined();
       });
-      test15("getOrCreate passes input to actor during creation", async (c) => {
+      test16("getOrCreate passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = [`input-test-${crypto.randomUUID()}`];
         const testInput = {
@@ -3002,16 +3201,16 @@ function runManagerDriverTests(driverTestConfig) {
           createWithInput: testInput
         });
         const inputs = await actor2.getInputs();
-        expect15(inputs.initialInput).toEqual(testInput);
-        expect15(inputs.onCreateInput).toEqual(testInput);
+        expect16(inputs.initialInput).toEqual(testInput);
+        expect16(inputs.onCreateInput).toEqual(testInput);
         const existingActor = client.inputActor.getOrCreate(uniqueKey);
         const existingInputs = await existingActor.getInputs();
-        expect15(existingInputs.initialInput).toEqual(testInput);
-        expect15(existingInputs.onCreateInput).toEqual(testInput);
+        expect16(existingInputs.initialInput).toEqual(testInput);
+        expect16(existingInputs.onCreateInput).toEqual(testInput);
       });
     });
-    describe16("Key Matching", () => {
-      test15("matches actors only with exactly the same keys", async (c) => {
+    describe17("Key Matching", () => {
+      test16("matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
           "counter-match",
@@ -3025,20 +3224,20 @@ function runManagerDriverTests(driverTestConfig) {
           "us-east"
         ]);
         const exactMatchCount = await exactMatchCounter.increment(0);
-        expect15(exactMatchCount).toBe(10);
+        expect16(exactMatchCount).toBe(10);
         const subsetMatchCounter = client.counter.getOrCreate([
           "counter-match",
           "test"
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
-        expect15(subsetMatchCount).toBe(0);
+        expect16(subsetMatchCount).toBe(0);
         const singleKeyCounter = client.counter.getOrCreate([
           "counter-match"
         ]);
         const singleKeyCount = await singleKeyCounter.increment(0);
-        expect15(singleKeyCount).toBe(0);
+        expect16(singleKeyCount).toBe(0);
       });
-      test15("string key matches array with single string key", async (c) => {
+      test16("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);
@@ -3046,20 +3245,20 @@ function runManagerDriverTests(driverTestConfig) {
           "string-key-test"
         ]);
         const count = await arrayKeyCounter.increment(0);
-        expect15(count).toBe(7);
+        expect16(count).toBe(7);
       });
-      test15("undefined key matches empty array key and no key", async (c) => {
+      test16("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);
-        expect15(emptyArrayCount).toBe(12);
+        expect16(emptyArrayCount).toBe(12);
         const noKeyCounter = client.counter.getOrCreate();
         const noKeyCount = await noKeyCounter.increment(0);
-        expect15(noKeyCount).toBe(12);
+        expect16(noKeyCount).toBe(12);
       });
-      test15("no keys does not match actors with keys", async (c) => {
+      test16("no keys does not match actors with keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const keyedCounter = client.counter.getOrCreate([
           "counter-with-keys",
@@ -3068,9 +3267,9 @@ function runManagerDriverTests(driverTestConfig) {
         await keyedCounter.increment(15);
         const noKeysCounter = client.counter.getOrCreate();
         const count = await noKeysCounter.increment(10);
-        expect15(count).toBe(10);
+        expect16(count).toBe(10);
       });
-      test15("actors with keys match actors with no keys", async (c) => {
+      test16("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);
@@ -3079,11 +3278,11 @@ function runManagerDriverTests(driverTestConfig) {
           "prod"
         ]);
         const keyedCount = await keyedCounter.increment(0);
-        expect15(keyedCount).toBe(0);
+        expect16(keyedCount).toBe(0);
       });
     });
-    describe16("Multiple Actor Instances", () => {
-      test15("creates multiple actor instances of the same type", async (c) => {
+    describe17("Multiple Actor Instances", () => {
+      test16("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"]);
@@ -3094,35 +3293,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"]);
-        expect15(await retrieved1.increment(0)).toBe(1);
-        expect15(await retrieved2.increment(0)).toBe(2);
-        expect15(await retrieved3.increment(0)).toBe(3);
+        expect16(await retrieved1.increment(0)).toBe(1);
+        expect16(await retrieved2.increment(0)).toBe(2);
+        expect16(await retrieved3.increment(0)).toBe(3);
       });
-      test15("handles default instance with no explicit ID", async (c) => {
+      test16("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);
-        expect15(count).toBe(5);
+        expect16(count).toBe(5);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http.ts
-import { describe as describe17, expect as expect16, test as test16 } from "vitest";
+import { describe as describe18, expect as expect17, test as test17 } from "vitest";
 function runRawHttpTests(driverTestConfig) {
-  describe17("raw http", () => {
-    test16("should handle raw HTTP GET requests", async (c) => {
+  describe18("raw http", () => {
+    test17("should handle raw HTTP GET requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["test"]);
       const helloResponse = await actor2.fetch("api/hello");
-      expect16(helloResponse.ok).toBe(true);
+      expect17(helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
-      expect16(helloData).toEqual({ message: "Hello from actor!" });
+      expect17(helloData).toEqual({ message: "Hello from actor!" });
     });
-    test16("should handle raw HTTP POST requests with echo", async (c) => {
+    test17("should handle raw HTTP POST requests with echo", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["test"]);
       const testData = { test: "data", number: 123 };
@@ -3133,22 +3332,22 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: JSON.stringify(testData)
       });
-      expect16(echoResponse.ok).toBe(true);
+      expect17(echoResponse.ok).toBe(true);
       const echoData = await echoResponse.json();
-      expect16(echoData).toEqual(testData);
+      expect17(echoData).toEqual(testData);
     });
-    test16("should track state across raw HTTP requests", async (c) => {
+    test17("should track state across raw HTTP requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["state-test"]);
       await actor2.fetch("api/hello");
       await actor2.fetch("api/hello");
       await actor2.fetch("api/state");
       const stateResponse = await actor2.fetch("api/state");
-      expect16(stateResponse.ok).toBe(true);
+      expect17(stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
-      expect16(stateData.requestCount).toBe(4);
+      expect17(stateData.requestCount).toBe(4);
     });
-    test16("should pass headers correctly", async (c) => {
+    test17("should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
@@ -3158,44 +3357,44 @@ function runRawHttpTests(driverTestConfig) {
       const response = await actor2.fetch("api/headers", {
         headers: customHeaders
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const headers = await response.json();
-      expect16(headers["x-custom-header"]).toBe("test-value");
-      expect16(headers["x-another-header"]).toBe("another-value");
+      expect17(headers["x-custom-header"]).toBe("test-value");
+      expect17(headers["x-another-header"]).toBe("another-value");
     });
-    test16("should return 404 for unhandled paths", async (c) => {
+    test17("should return 404 for unhandled paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["404-test"]);
       const response = await actor2.fetch("api/nonexistent");
-      expect16(response.ok).toBe(false);
-      expect16(response.status).toBe(404);
+      expect17(response.ok).toBe(false);
+      expect17(response.status).toBe(404);
     });
-    test16("should return 404 when no onFetch handler defined", async (c) => {
+    test17("should return 404 when no onRequest handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpNoHandlerActor.getOrCreate([
         "no-handler"
       ]);
       const response = await actor2.fetch("api/anything");
-      expect16(response.ok).toBe(false);
-      expect16(response.status).toBe(404);
+      expect17(response.ok).toBe(false);
+      expect17(response.status).toBe(404);
     });
-    test16("should return 500 error when onFetch returns void", async (c) => {
+    test17("should return 500 error when onRequest returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpVoidReturnActor.getOrCreate([
         "void-return"
       ]);
       const response = await actor2.fetch("api/anything");
-      expect16(response.ok).toBe(false);
-      expect16(response.status).toBe(500);
+      expect17(response.ok).toBe(false);
+      expect17(response.status).toBe(500);
       try {
         const errorData = await response.json();
-        expect16(errorData.message).toContain(
-          "onFetch handler must return a Response"
+        expect17(errorData.message).toContain(
+          "onRequest handler must return a Response"
         );
       } catch {
       }
     });
-    test16("should handle different HTTP methods", async (c) => {
+    test17("should handle different HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["methods-test"]);
       const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
@@ -3205,17 +3404,17 @@ function runRawHttpTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "POST") {
-          expect16(response.ok).toBe(true);
+          expect17(response.ok).toBe(true);
           const data = await response.json();
-          expect16(data).toEqual({ method });
+          expect17(data).toEqual({ method });
         } else if (method === "GET") {
-          expect16(response.status).toBe(404);
+          expect17(response.status).toBe(404);
         } else {
-          expect16(response.status).toBe(404);
+          expect17(response.status).toBe(404);
         }
       }
     });
-    test16("should handle binary data", async (c) => {
+    test17("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["binary-test"]);
       const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
@@ -3226,82 +3425,82 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: binaryData
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const responseBuffer = await response.arrayBuffer();
       const responseArray = new Uint8Array(responseBuffer);
-      expect16(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+      expect17(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
     });
-    test16("should work with Hono router using createVars", async (c) => {
+    test17("should work with Hono router using createVars", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
       const rootResponse = await actor2.fetch("/");
-      expect16(rootResponse.ok).toBe(true);
+      expect17(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect16(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      expect17(rootData).toEqual({ message: "Welcome to Hono actor!" });
       const usersResponse = await actor2.fetch("/users");
-      expect16(usersResponse.ok).toBe(true);
+      expect17(usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
-      expect16(users).toEqual([
+      expect17(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
       const userResponse = await actor2.fetch("/users/1");
-      expect16(userResponse.ok).toBe(true);
+      expect17(userResponse.ok).toBe(true);
       const user = await userResponse.json();
-      expect16(user).toEqual({ id: 1, name: "Alice" });
+      expect17(user).toEqual({ id: 1, name: "Alice" });
       const newUser = { name: "Charlie" };
       const createResponse = await actor2.fetch("/users", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(newUser)
       });
-      expect16(createResponse.ok).toBe(true);
-      expect16(createResponse.status).toBe(201);
+      expect17(createResponse.ok).toBe(true);
+      expect17(createResponse.status).toBe(201);
       const createdUser = await createResponse.json();
-      expect16(createdUser).toEqual({ id: 3, name: "Charlie" });
+      expect17(createdUser).toEqual({ id: 3, name: "Charlie" });
       const updateData = { name: "Alice Updated" };
       const updateResponse = await actor2.fetch("/users/1", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(updateData)
       });
-      expect16(updateResponse.ok).toBe(true);
+      expect17(updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
-      expect16(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      expect17(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
       const deleteResponse = await actor2.fetch("/users/2", {
         method: "DELETE"
       });
-      expect16(deleteResponse.ok).toBe(true);
+      expect17(deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
-      expect16(deleteResult).toEqual({ message: "User 2 deleted" });
+      expect17(deleteResult).toEqual({ message: "User 2 deleted" });
       const notFoundResponse = await actor2.fetch("/api/unknown");
-      expect16(notFoundResponse.ok).toBe(false);
-      expect16(notFoundResponse.status).toBe(404);
+      expect17(notFoundResponse.ok).toBe(false);
+      expect17(notFoundResponse.status).toBe(404);
     });
-    test16("should handle paths with and without leading slashes", async (c) => {
+    test17("should handle paths with and without leading slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["path-test"]);
       const responseWithoutSlash = await actor2.fetch("api/hello");
-      expect16(responseWithoutSlash.ok).toBe(true);
+      expect17(responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
-      expect16(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      expect17(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
       const responseWithSlash = await actor2.fetch("/api/hello");
-      expect16(responseWithSlash.ok).toBe(true);
+      expect17(responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
-      expect16(dataWithSlash).toEqual({ message: "Hello from actor!" });
+      expect17(dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
-    test16("should not create double slashes in request URLs", async (c) => {
+    test17("should not create double slashes in request URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpHonoActor.getOrCreate(["url-test"]);
       const response = await actor2.fetch("/users");
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data).toEqual([
+      expect17(data).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test16("should handle forwarded requests correctly without double slashes", async (c) => {
+    test17("should handle forwarded requests correctly without double slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
       const truncatedPath = "/users";
@@ -3313,14 +3512,14 @@ function runRawHttpTests(driverTestConfig) {
         truncatedPath,
         newRequest
       );
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const users = await response.json();
-      expect16(users).toEqual([
+      expect17(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test16("example fix: should properly forward requests using just Request object", async (c) => {
+    test17("example fix: should properly forward requests using just Request object", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
       const truncatedPath = "/users/1";
@@ -3329,11 +3528,11 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor2.fetch(newRequest);
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const user = await response.json();
-      expect16(user).toEqual({ id: 1, name: "Alice" });
+      expect17(user).toEqual({ id: 1, name: "Alice" });
     });
-    test16("should support standard fetch API with URL and Request objects", async (c) => {
+    test17("should support standard fetch API with URL and Request objects", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
       const url = new URL("/api/echo", "http://example.com");
@@ -3342,18 +3541,18 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
       });
-      expect16(urlResponse.ok).toBe(true);
+      expect17(urlResponse.ok).toBe(true);
       const urlData = await urlResponse.json();
-      expect16(urlData).toEqual({ from: "URL object" });
+      expect17(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 actor2.fetch(request);
-      expect16(requestResponse.ok).toBe(true);
+      expect17(requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
-      expect16(requestData).toEqual({ from: "Request object" });
+      expect17(requestData).toEqual({ from: "Request object" });
       const request2 = new Request("http://example.com/api/headers", {
         method: "GET",
         headers: { "X-Original": "request-header" }
@@ -3361,19 +3560,19 @@ function runRawHttpTests(driverTestConfig) {
       const overrideResponse = await actor2.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
-      expect16(overrideResponse.ok).toBe(true);
+      expect17(overrideResponse.ok).toBe(true);
       const headers = await overrideResponse.json();
-      expect16(headers["x-override"]).toBe("init-header");
-      expect16(headers["x-original"]).toBe("request-header");
+      expect17(headers["x-override"]).toBe("init-header");
+      expect17(headers["x-original"]).toBe("request-header");
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http-request-properties.ts
-import { describe as describe18, expect as expect17, test as test17 } from "vitest";
+import { describe as describe19, expect as expect18, test as test18 } from "vitest";
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
-  describe18("raw http request properties", () => {
-    test17("should pass all Request properties correctly to onFetch", async (c) => {
+  describe19("raw http request properties", () => {
+    test18("should pass all Request properties correctly to onRequest", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3387,22 +3586,22 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify({ test: "data" })
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.url).toContain("/test/path?foo=bar&baz=qux");
-      expect17(data.pathname).toBe("/test/path");
-      expect17(data.search).toBe("?foo=bar&baz=qux");
-      expect17(data.searchParams).toEqual({
+      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({
         foo: "bar",
         baz: "qux"
       });
-      expect17(data.method).toBe("POST");
-      expect17(data.headers["content-type"]).toBe("application/json");
-      expect17(data.headers["x-custom-header"]).toBe("custom-value");
-      expect17(data.headers["authorization"]).toBe("Bearer test-token");
-      expect17(data.body).toEqual({ test: "data" });
+      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" });
     });
-    test17("should handle GET requests with no body", async (c) => {
+    test18("should handle GET requests with no body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3410,12 +3609,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor2.fetch("test/get", {
         method: "GET"
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.method).toBe("GET");
-      expect17(data.body).toBeNull();
+      expect18(data.method).toBe("GET");
+      expect18(data.body).toBeNull();
     });
-    test17("should handle different content types", async (c) => {
+    test18("should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3430,12 +3629,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: formData.toString()
       });
-      expect17(formResponse.ok).toBe(true);
+      expect18(formResponse.ok).toBe(true);
       const formResult = await formResponse.json();
-      expect17(formResult.headers["content-type"]).toBe(
+      expect18(formResult.headers["content-type"]).toBe(
         "application/x-www-form-urlencoded"
       );
-      expect17(formResult.bodyText).toBe("field1=value1&field2=value2");
+      expect18(formResult.bodyText).toBe("field1=value1&field2=value2");
       const textResponse = await actor2.fetch("test/text", {
         method: "POST",
         headers: {
@@ -3443,12 +3642,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: "Hello, World!"
       });
-      expect17(textResponse.ok).toBe(true);
+      expect18(textResponse.ok).toBe(true);
       const textResult = await textResponse.json();
-      expect17(textResult.headers["content-type"]).toBe("text/plain");
-      expect17(textResult.bodyText).toBe("Hello, World!");
+      expect18(textResult.headers["content-type"]).toBe("text/plain");
+      expect18(textResult.bodyText).toBe("Hello, World!");
     });
-    test17("should preserve all header casing and values", async (c) => {
+    test18("should preserve all header casing and values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3462,38 +3661,38 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           "X-Request-ID": "12345"
         }
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.headers["accept"]).toBe("application/json");
-      expect17(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
-      expect17(data.headers["cache-control"]).toBe("no-cache");
-      expect17(data.headers["user-agent"]).toBeTruthy();
-      expect17(data.headers["x-request-id"]).toBe("12345");
+      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");
     });
-    test17("should handle empty and special URL paths", async (c) => {
+    test18("should handle empty and special URL paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const rootResponse = await actor2.fetch("");
-      expect17(rootResponse.ok).toBe(true);
+      expect18(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect17(rootData.pathname).toBe("/");
+      expect18(rootData.pathname).toBe("/");
       const specialResponse = await actor2.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
-      expect17(specialResponse.ok).toBe(true);
+      expect18(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect17(specialData.pathname).toMatch(
+      expect18(specialData.pathname).toMatch(
         /path.*with.*spaces.*and.*slashes/
       );
       const fragmentResponse = await actor2.fetch("test/path#fragment");
-      expect17(fragmentResponse.ok).toBe(true);
+      expect18(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
-      expect17(fragmentData.pathname).toBe("/test/path");
-      expect17(fragmentData.hash).toBe("");
+      expect18(fragmentData.pathname).toBe("/test/path");
+      expect18(fragmentData.hash).toBe("");
     });
-    test17("should handle request properties for all HTTP methods", async (c) => {
+    test18("should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3517,21 +3716,21 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           }
         );
         if (method === "HEAD") {
-          expect17(response.status).toBe(200);
+          expect18(response.status).toBe(200);
           const text = await response.text();
-          expect17(text).toBe("");
+          expect18(text).toBe("");
         } else if (method === "OPTIONS") {
-          expect17(response.status).toBe(204);
+          expect18(response.status).toBe(204);
           const text = await response.text();
-          expect17(text).toBe("");
+          expect18(text).toBe("");
         } else {
-          expect17(response.ok).toBe(true);
+          expect18(response.ok).toBe(true);
           const data = await response.json();
-          expect17(data.method).toBe(method);
+          expect18(data.method).toBe(method);
         }
       }
     });
-    test17("should handle complex query parameters", async (c) => {
+    test18("should handle complex query parameters", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3539,13 +3738,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor2.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.searchParams.key).toBe("value2");
-      expect17(data.searchParams["array[]"]).toBe("2");
-      expect17(data.searchParams["nested[prop]"]).toBe("val");
+      expect18(data.searchParams.key).toBe("value2");
+      expect18(data.searchParams["array[]"]).toBe("2");
+      expect18(data.searchParams["nested[prop]"]).toBe("val");
     });
-    test17("should handle multipart form data", async (c) => {
+    test18("should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3569,27 +3768,27 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.headers["content-type"]).toContain(
+      expect18(data.headers["content-type"]).toContain(
         "multipart/form-data"
       );
-      expect17(data.bodyText).toContain("field1");
-      expect17(data.bodyText).toContain("value1");
+      expect18(data.bodyText).toContain("field1");
+      expect18(data.bodyText).toContain("value1");
     });
-    test17("should handle very long URLs", async (c) => {
+    test18("should handle very long URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const longValue = "x".repeat(1e3);
       const response = await actor2.fetch(`test/long?param=${longValue}`);
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.searchParams.param).toBe(longValue);
-      expect17(data.search.length).toBeGreaterThan(1e3);
+      expect18(data.searchParams.param).toBe(longValue);
+      expect18(data.search.length).toBeGreaterThan(1e3);
     });
-    test17("should handle large request bodies", async (c) => {
+    test18.skip("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3606,11 +3805,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify(largeArray)
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.body).toHaveLength(1e4);
+      expect18(data.body).toHaveLength(1e4);
     });
-    test17("should handle missing content-type header", async (c) => {
+    test18("should handle missing content-type header", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3619,11 +3818,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         method: "POST",
         body: "plain text without content-type"
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.bodyText).toBe("plain text without content-type");
+      expect18(data.bodyText).toBe("plain text without content-type");
     });
-    test17("should handle empty request body", async (c) => {
+    test18("should handle empty request body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3635,12 +3834,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: ""
       });
-      expect17(response.ok).toBe(true);
-      const data = await response.json();
-      expect17(data.body).toBeNull();
-      expect17(data.bodyText).toBe("");
+      expect18(response.ok).toBe(true);
     });
-    test17("should handle custom HTTP methods", async (c) => {
+    test18("should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3651,12 +3847,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         });
         if (response.ok) {
           const data = await response.json();
-          expect17(data.method).toBe("CUSTOM");
+          expect18(data.method).toBe("CUSTOM");
         }
       } catch (error) {
       }
     });
-    test17("should handle cookies in headers", async (c) => {
+    test18("should handle cookies in headers", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3666,13 +3862,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
       });
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.headers.cookie).toBe(
+      expect18(data.headers.cookie).toBe(
         "session=abc123; user=test; preferences=dark_mode"
       );
     });
-    test17("should handle URL encoding properly", async (c) => {
+    test18("should handle URL encoding properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3680,13 +3876,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor2.fetch(
         "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
       );
-      expect17(response.ok).toBe(true);
+      expect18(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.searchParams.special).toBe(" !@#$%^&");
-      expect17(data.searchParams.unicode).toBe("\u2713");
-      expect17(data.searchParams.email).toBe("test@example.com");
+      expect18(data.searchParams.special).toBe(" !@#$%^&");
+      expect18(data.searchParams.unicode).toBe("\u2713");
+      expect18(data.searchParams.email).toBe("test@example.com");
     });
-    test17("should handle concurrent requests maintaining separate contexts", async (c) => {
+    test18("should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3710,24 +3906,24 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const results = await Promise.all(
         responses.map((r) => r.json())
       );
-      expect17(results[0].searchParams.id).toBe("1");
-      expect17(results[0].method).toBe("POST");
-      expect17(results[0].body).toEqual({ request: 1 });
-      expect17(results[1].searchParams.id).toBe("2");
-      expect17(results[1].method).toBe("PUT");
-      expect17(results[1].body).toEqual({ request: 2 });
-      expect17(results[2].searchParams.id).toBe("3");
-      expect17(results[2].method).toBe("DELETE");
-      expect17(results[2].body).toBeNull();
+      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();
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-websocket.ts
-import { describe as describe19, expect as expect18, test as test18 } from "vitest";
+import { describe as describe20, expect as expect19, test as test19 } from "vitest";
 function runRawWebSocketTests(driverTestConfig) {
-  describe19("raw websocket", () => {
-    test18("should establish raw WebSocket connection", async (c) => {
+  describe20("raw websocket", () => {
+    test19("should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
       const ws = await actor2.websocket();
@@ -3754,11 +3950,11 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect18(welcomeMessage.type).toBe("welcome");
-      expect18(welcomeMessage.connectionCount).toBe(1);
+      expect19(welcomeMessage.type).toBe("welcome");
+      expect19(welcomeMessage.connectionCount).toBe(1);
       ws.close();
     });
-    test18("should echo messages", async (c) => {
+    test19("should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
       const ws = await actor2.websocket();
@@ -3786,10 +3982,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect18(echoMessage).toEqual(testMessage);
+      expect19(echoMessage).toEqual(testMessage);
       ws.close();
     });
-    test18("should handle ping/pong protocol", async (c) => {
+    test19("should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
       const ws = await actor2.websocket();
@@ -3815,11 +4011,11 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect18(pongMessage.type).toBe("pong");
-      expect18(pongMessage.timestamp).toBeDefined();
+      expect19(pongMessage.type).toBe("pong");
+      expect19(pongMessage.timestamp).toBeDefined();
       ws.close();
     });
-    test18("should track stats across connections", async (c) => {
+    test19("should track stats across connections", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.websocket();
@@ -3863,15 +4059,15 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws1.send(JSON.stringify({ type: "getStats" }));
       const stats = await statsPromise;
-      expect18(stats.connectionCount).toBe(2);
-      expect18(stats.messageCount).toBe(4);
+      expect19(stats.connectionCount).toBe(2);
+      expect19(stats.messageCount).toBe(4);
       const actionStats = await actor1.getStats();
-      expect18(actionStats.connectionCount).toBe(2);
-      expect18(actionStats.messageCount).toBe(4);
+      expect19(actionStats.connectionCount).toBe(2);
+      expect19(actionStats.messageCount).toBe(4);
       ws1.close();
       ws2.close();
     });
-    test18("should handle binary data", async (c) => {
+    test19("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketBinaryActor.getOrCreate([
         "binary"
@@ -3904,7 +4100,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const smallData = new Uint8Array([1, 2, 3, 4, 5]);
       ws.send(smallData);
       const smallReversed = await receiveBinaryMessage();
-      expect18(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
+      expect19(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;
@@ -3912,13 +4108,13 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        expect18(largeReversed[i]).toBe(
+        expect19(largeReversed[i]).toBe(
           largeData[largeData.length - 1 - i]
         );
       }
       ws.close();
     });
-    test18("should work with custom paths", async (c) => {
+    test19("should work with custom paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["paths"]);
       const ws = await actor2.websocket("custom/path");
@@ -3938,10 +4134,10 @@ function runRawWebSocketTests(driverTestConfig) {
           { once: true }
         );
       });
-      expect18(welcomeMessage.type).toBe("welcome");
+      expect19(welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    test18("should handle connection close properly", async (c) => {
+    test19("should handle connection close properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["close-test"]);
       const ws = await actor2.websocket();
@@ -3954,7 +4150,7 @@ function runRawWebSocketTests(driverTestConfig) {
         });
       }
       const initialStats = await actor2.getStats();
-      expect18(initialStats.connectionCount).toBe(1);
+      expect19(initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve) => {
         ws.addEventListener("close", () => resolve(), { once: true });
       });
@@ -3968,9 +4164,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect18(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test18("should properly handle onWebSocket open and close events", async (c) => {
+    test19("should properly handle onWebSocket open and close events", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate([
         "open-close-test"
@@ -3990,8 +4186,8 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws1.addEventListener("close", reject);
       });
-      expect18(welcome1.type).toBe("welcome");
-      expect18(welcome1.connectionCount).toBe(1);
+      expect19(welcome1.type).toBe("welcome");
+      expect19(welcome1.connectionCount).toBe(1);
       const ws2 = await actor2.websocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
@@ -4007,10 +4203,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws2.addEventListener("close", reject);
       });
-      expect18(welcome2.type).toBe("welcome");
-      expect18(welcome2.connectionCount).toBe(2);
+      expect19(welcome2.type).toBe("welcome");
+      expect19(welcome2.connectionCount).toBe(2);
       const midStats = await actor2.getStats();
-      expect18(midStats.connectionCount).toBe(2);
+      expect19(midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve) => {
         ws1.addEventListener("close", () => resolve(), { once: true });
@@ -4023,7 +4219,7 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect18(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      expect19(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
       await new Promise((resolve) => {
         ws2.addEventListener("close", () => resolve(), { once: true });
@@ -4036,9 +4232,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect18(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test18("should handle query parameters in websocket paths", async (c) => {
+    test19("should handle query parameters in websocket paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate([
         "query-params"
@@ -4061,19 +4257,19 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect18(requestInfo.url).toContain("api/v1/stream");
-      expect18(requestInfo.url).toContain("token=abc123");
-      expect18(requestInfo.url).toContain("user=test");
+      expect19(requestInfo.url).toContain("api/v1/stream");
+      expect19(requestInfo.url).toContain("token=abc123");
+      expect19(requestInfo.url).toContain("user=test");
       ws.close();
     });
   });
 }
 
 // src/driver-test-suite/tests/request-access.ts
-import { describe as describe20, expect as expect19, test as test19 } from "vitest";
+import { describe as describe21, expect as expect20, test as test20 } from "vitest";
 function runRequestAccessTests(driverTestConfig) {
-  describe20("Request Access in Lifecycle Hooks", () => {
-    test19("should have access to request object in onBeforeConnect and createConnState", async (c) => {
+  describe21("Request Access in Lifecycle Hooks", () => {
+    test20("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"],
@@ -4084,23 +4280,23 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect19(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect19(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
-        expect19(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        expect19(
+        expect20(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect20(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect20(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect20(
           requestInfo.onBeforeConnect.requestHeaders
         ).toBeDefined();
-        expect19(requestInfo.createConnState.hasRequest).toBe(true);
-        expect19(requestInfo.createConnState.requestUrl).toBeDefined();
-        expect19(requestInfo.createConnState.requestMethod).toBeDefined();
-        expect19(
+        expect20(requestInfo.createConnState.hasRequest).toBe(true);
+        expect20(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect20(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect20(
           requestInfo.createConnState.requestHeaders
         ).toBeDefined();
       } else {
       }
       await connection.dispose();
     });
-    test19("should not have request when trackRequest is false", async (c) => {
+    test20("should not have request when trackRequest is false", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-no-request"],
@@ -4110,21 +4306,21 @@ function runRequestAccessTests(driverTestConfig) {
       );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
-      expect19(requestInfo.onBeforeConnect.hasRequest).toBe(false);
-      expect19(requestInfo.onBeforeConnect.requestUrl).toBeNull();
-      expect19(requestInfo.onBeforeConnect.requestMethod).toBeNull();
-      expect19(
+      expect20(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect20(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect20(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect20(
         Object.keys(requestInfo.onBeforeConnect.requestHeaders)
       ).toHaveLength(0);
-      expect19(requestInfo.createConnState.hasRequest).toBe(false);
-      expect19(requestInfo.createConnState.requestUrl).toBeNull();
-      expect19(requestInfo.createConnState.requestMethod).toBeNull();
-      expect19(
+      expect20(requestInfo.createConnState.hasRequest).toBe(false);
+      expect20(requestInfo.createConnState.requestUrl).toBeNull();
+      expect20(requestInfo.createConnState.requestMethod).toBeNull();
+      expect20(
         Object.keys(requestInfo.createConnState.requestHeaders)
       ).toHaveLength(0);
       await connection.dispose();
     });
-    test19("should capture request headers and method", async (c) => {
+    test20("should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-headers"],
@@ -4135,18 +4331,18 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect19(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect19(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
-        expect19(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
-        expect19(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
-        expect19(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+        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(
           "object"
         );
-        expect19(requestInfo.createConnState.hasRequest).toBe(true);
-        expect19(requestInfo.createConnState.requestMethod).toBeTruthy();
-        expect19(requestInfo.createConnState.requestUrl).toBeTruthy();
-        expect19(requestInfo.createConnState.requestHeaders).toBeTruthy();
-        expect19(typeof requestInfo.createConnState.requestHeaders).toBe(
+        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(
           "object"
         );
       } else {
@@ -4161,11 +4357,10 @@ function runDriverTests(driverTestConfigPartial) {
   var _a;
   const clientTypes = ((_a = driverTestConfigPartial.skip) == null ? void 0 : _a.inline) ? ["http"] : ["http", "inline"];
   for (const clientType of clientTypes) {
-    describe21(`client type (${clientType})`, () => {
+    describe22(`client type (${clientType})`, () => {
       const encodings = ["bare", "cbor", "json"];
       for (const encoding of encodings) {
-        describe21(`encoding (${encoding})`, () => {
-          var _a2;
+        describe22(`encoding (${encoding})`, () => {
           const driverTestConfig = {
             ...driverTestConfigPartial,
             clientType,
@@ -4173,31 +4368,11 @@ function runDriverTests(driverTestConfigPartial) {
           };
           runActorDriverTests(driverTestConfig);
           runManagerDriverTests(driverTestConfig);
-          const transports = ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sse) ? ["websocket"] : ["websocket", "sse"];
-          for (const transport of transports) {
-            describe21(`transport (${transport})`, () => {
-              runActorConnTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorConnStateTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorReconnectTests({
-                ...driverTestConfig,
-                transport
-              });
-              runRequestAccessTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorDriverTestsWithTransport({
-                ...driverTestConfig,
-                transport
-              });
-            });
-          }
+          runActorConnTests(driverTestConfig);
+          runActorConnStateTests(driverTestConfig);
+          runActorConnHibernationTests(driverTestConfig);
+          runActorDestroyTests(driverTestConfig);
+          runRequestAccessTests(driverTestConfig);
           runActorHandleTests(driverTestConfig);
           runActionFeaturesTests(driverTestConfig);
           runActorVarsTests(driverTestConfig);
@@ -4215,11 +4390,7 @@ function runDriverTests(driverTestConfigPartial) {
   }
 }
 async function createTestRuntime(registryPath, driverFactory) {
-  const {
-    mod: { registry }
-  } = await bundleRequire({
-    filepath: registryPath
-  });
+  const { registry } = await import(registryPath);
   registry.config.test.enabled = true;
   const {
     driver,