rivetkit 2.0.6 → 2.0.7-rc.1

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

@@ -1,37 +1,46 @@
 import {
   getPort
-} from "../chunk-G75SVQON.js";
+} from "../chunk-SBKRVQS2.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-W6LN7AF5.js";
+} from "../chunk-HPT3I7UU.js";
 import {
+  configureInspectorAccessToken,
   createActorInspectorClient,
   createManagerInspectorClient
-} from "../chunk-42I3OZ3Q.js";
+} from "../chunk-4GP7BZSR.js";
 import {
   createClient
-} from "../chunk-VPV4MWXR.js";
+} from "../chunk-7N56ZUC7.js";
 import {
   ActorError,
   createClientWithDriver
-} from "../chunk-4CKHQRXG.js";
-import "../chunk-ZYLTS2EM.js";
+} from "../chunk-BW5DPM6Z.js";
+import "../chunk-GZVBFXBI.js";
 import {
   importWebSocket
-} from "../chunk-VCEHU56K.js";
+} from "../chunk-E4UVJKSV.js";
 import {
   RunConfigSchema
-} from "../chunk-7OUKNSTU.js";
+} from "../chunk-JD54PXWP.js";
 import {
   HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
+  WS_PROTOCOL_ACTOR,
+  WS_PROTOCOL_CONN_PARAMS,
+  WS_PROTOCOL_ENCODING,
+  WS_PROTOCOL_PATH,
+  WS_PROTOCOL_TARGET,
+  WS_PROTOCOL_TRANSPORT,
   assertUnreachable
-} from "../chunk-2K3JMDAN.js";
+} from "../chunk-YQ4XQYPM.js";
 import {
   getLogger
-} from "../chunk-WC2PSJWN.js";
-import "../chunk-RGQR2J7S.js";
+} from "../chunk-PUSQNDJG.js";
+import {
+  promiseWithResolvers
+} from "../chunk-RVP5RUSC.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
@@ -41,8 +50,8 @@ import {
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket } from "@hono/node-ws";
 import { bundleRequire } from "bundle-require";
-import invariant2 from "invariant";
-import { describe as describe20 } from "vitest";
+import invariant from "invariant";
+import { describe as describe21 } from "vitest";
 
 // src/driver-test-suite/log.ts
 function logger() {
@@ -53,7 +62,6 @@ function logger() {
 import { describe, expect, test } from "vitest";
 
 // src/driver-test-suite/utils.ts
-import invariant from "invariant";
 import { vi } from "vitest";
 
 // src/driver-test-suite/test-inline-client-driver.ts
@@ -104,7 +112,8 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
           method: actorRequest.method,
           headers,
           body: actorRequest.body,
-          signal: actorRequest.signal
+          signal: actorRequest.signal,
+          duplex: "half"
         })
       );
       if (!response.ok && ((_a = response.headers.get("content-type")) == null ? void 0 : _a.includes("application/json"))) {
@@ -129,38 +138,46 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       }
       return response;
     },
-    async openWebSocket(path, actorId, encoding2, params) {
+    async openWebSocket(path, actorId, encoding2, params, connId, connToken) {
       const WebSocket2 = await importWebSocket();
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-      logger().debug({
-        msg: "creating websocket connection via test inline driver"
-      });
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      wsUrl.searchParams.set("path", normalizedPath);
-      wsUrl.searchParams.set("actorId", actorId);
-      if (params !== void 0)
-        wsUrl.searchParams.set("params", JSON.stringify(params));
-      wsUrl.searchParams.set("encodingKind", encoding2);
+      logger().debug({
+        msg: "creating websocket connection via test inline driver",
+        url: wsUrl.toString()
+      });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
-      const ws = new WebSocket2(finalWsUrl, [
-        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
-        "rivetkit"
-      ]);
+      const protocols = [];
+      protocols.push(`${WS_PROTOCOL_TARGET}actor`);
+      protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+      protocols.push(`${WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${WS_PROTOCOL_TRANSPORT}${transport}`);
+      protocols.push(
+        `${WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+      );
+      if (params !== void 0) {
+        protocols.push(
+          `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+        );
+      }
+      const ws = new WebSocket2(finalWsUrl, protocols);
       return ws;
     },
     async proxyRequest(c, actorRequest, actorId) {
       return await this.sendRequest(actorId, actorRequest);
     },
-    proxyWebSocket(_c, _path, _actorId, _encoding, _params, _authData) {
+    proxyWebSocket(_c, _path, _actorId, _encoding, _params) {
       throw "UNIMPLEMENTED";
     },
     displayInformation() {
       return { name: "Test Inline", properties: {} };
-    }
+    },
+    // TODO:
+    getOrCreateInspectorAccessToken: () => ""
     // action: async <Args extends Array<unknown> = unknown[], Response = unknown>(
     // 	_c: HonoContext | undefined,
     // 	actorQuery: ActorQuery,
@@ -496,7 +513,8 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
       transport,
       method,
       args
-    })
+    }),
+    duplex: "half"
   });
   if (!response.ok) {
     throw new Error(`Failed to call inline ${method}: ${response.statusText}`);
@@ -537,14 +555,14 @@ async function setupDriverTest(c, driverTestConfig) {
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
+    const transport = driverTestConfig.transport ?? "websocket";
     const managerDriver = createTestInlineClientDriver(
       endpoint,
       "bare",
-      driverTestConfig.transport ?? "websocket"
+      transport
     );
-    invariant(driverTestConfig.transport, "missing transport");
     const runConfig = RunConfigSchema.parse({
-      transport: driverTestConfig.transport
+      transport
     });
     client = createClientWithDriver(managerDriver, runConfig);
   } else {
@@ -649,7 +667,7 @@ function runActionFeaturesTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-conn.ts
-import { describe as describe2, expect as expect2, test as test2 } from "vitest";
+import { describe as describe2, expect as expect2, test as test2, vi as vi2 } from "vitest";
 function runActorConnTests(driverTestConfig) {
   describe2("Actor Connection Tests", () => {
     describe2("Connection Methods", () => {
@@ -696,17 +714,19 @@ function runActorConnTests(driverTestConfig) {
         const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
         const connection = handle.connect();
         const receivedEvents = [];
-        const receivedEventsPromise = new Promise((resolve) => {
-          connection.on("newCount", (count) => {
-            receivedEvents.push(count);
-            if (receivedEvents.includes(1) && receivedEvents.includes(6) && receivedEvents.includes(9))
-              resolve(void 0);
-          });
+        connection.on("newCount", (count) => {
+          receivedEvents.push(count);
+        });
+        await vi2.waitFor(async () => {
+          await connection.setCount(1);
+          expect2(receivedEvents).includes(1);
+        });
+        await handle.setCount(2);
+        await handle.setCount(3);
+        await vi2.waitFor(() => {
+          expect2(receivedEvents).includes(2);
+          expect2(receivedEvents).includes(3);
         });
-        await connection.increment(1);
-        await handle.increment(5);
-        await handle.increment(3);
-        await receivedEventsPromise;
         await connection.dispose();
       });
       test2("should receive events via broadcast", async (c) => {
@@ -717,10 +737,15 @@ function runActorConnTests(driverTestConfig) {
         connection.on("newCount", (count) => {
           receivedEvents.push(count);
         });
-        await connection.increment(5);
-        await connection.increment(3);
-        expect2(receivedEvents).toContain(5);
-        expect2(receivedEvents).toContain(8);
+        await vi2.waitFor(
+          async () => {
+            await connection.setCount(5);
+            await connection.setCount(8);
+            expect2(receivedEvents).toContain(5);
+            expect2(receivedEvents).toContain(8);
+          },
+          { timeout: 1e4 }
+        );
         await connection.dispose();
       });
       test2("should handle one-time events with once()", async (c) => {
@@ -733,8 +758,10 @@ function runActorConnTests(driverTestConfig) {
         });
         await connection.increment(5);
         await connection.increment(3);
-        expect2(receivedEvents).toEqual([5]);
-        expect2(receivedEvents).not.toContain(8);
+        await vi2.waitFor(() => {
+          expect2(receivedEvents).toEqual([5]);
+          expect2(receivedEvents).not.toContain(8);
+        });
         await connection.dispose();
       });
       test2("should unsubscribe from events", async (c) => {
@@ -745,10 +772,12 @@ function runActorConnTests(driverTestConfig) {
         const unsubscribe = connection.on("newCount", (count) => {
           receivedEvents.push(count);
         });
-        await connection.increment(5);
+        await vi2.waitFor(async () => {
+          await connection.setCount(5);
+          expect2(receivedEvents).toEqual([5]);
+        });
         unsubscribe();
-        await connection.increment(3);
-        expect2(receivedEvents).toEqual([5]);
+        await connection.setCount(8);
         expect2(receivedEvents).not.toContain(8);
         await connection.dispose();
       });
@@ -774,7 +803,9 @@ function runActorConnTests(driverTestConfig) {
       });
     });
     describe2("Lifecycle Hooks", () => {
-      test2("should trigger lifecycle hooks", async (c) => {
+      test2.skipIf(
+        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
+      )("should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -786,81 +817,30 @@ function runActorConnTests(driverTestConfig) {
         const events = await connection.getEvents();
         expect2(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
         await connection.dispose();
-        const handle = client.counterWithLifecycle.getOrCreate([
-          "test-lifecycle"
-        ]);
-        const finalEvents = await handle.getEvents();
-        expect2(finalEvents).toBeOneOf([
-          // Still active
-          ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
-          // Went to sleep and woke back up
-          [
-            "onStart",
-            "onBeforeConnect",
-            "onConnect",
-            "onDisconnect",
-            "onStart"
-          ]
-        ]);
-      });
-    });
-    describe2("Connection Liveness", () => {
-      test2.skip("should return correct liveness status for connections", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.connLivenessActor.getOrCreate([
-          "test-liveness-status"
-        ]);
-        const connA = handle.connect();
-        const connB = handle.connect();
-        const connAId = await connA.getConnectionId();
-        const connBId = await connB.getConnectionId();
-        await connA.increment(5);
-        await connB.increment(5);
-        const counter = await handle.getCounter();
-        expect2(counter).toBe(10);
-        const connectionsStatusBeforeKill = await handle.getWsConnectionsLiveness();
-        expect2(connectionsStatusBeforeKill).toHaveLength(2);
-        expect2(connectionsStatusBeforeKill).toContainEqual(
-          expect2.objectContaining({
-            id: connAId,
-            status: "connected",
-            lastSeen: FAKE_TIME.getTime()
-          })
-        );
-        expect2(connectionsStatusBeforeKill).toContainEqual(
-          expect2.objectContaining({
-            id: connBId,
-            status: "connected",
-            lastSeen: FAKE_TIME.getTime()
-          })
-        );
-        await handle.kill(connAId);
-        const connectionsStatusAfterKill = await handle.getWsConnectionsLiveness();
-        expect2(connectionsStatusAfterKill).toEqual(
-          expect2.arrayContaining([
-            expect2.objectContaining({
-              id: connAId,
-              status: "reconnecting",
-              lastSeen: FAKE_TIME.getTime()
-            }),
-            expect2.objectContaining({
-              id: connBId,
-              status: "connected",
-              lastSeen: FAKE_TIME.getTime()
-            })
-          ])
-        );
-        await waitFor(driverTestConfig, 5e3);
-        const connectionsStatusAfterCleanup = await handle.getWsConnectionsLiveness();
-        expect2(connectionsStatusAfterCleanup).not.toContainEqual(
-          expect2.objectContaining({
-            id: connAId
-          })
-        );
-        expect2(connectionsStatusAfterCleanup).toContainEqual(
-          expect2.objectContaining({
-            id: connBId
-          })
+        await vi2.waitFor(
+          async () => {
+            const handle = client.counterWithLifecycle.getOrCreate([
+              "test-lifecycle"
+            ]);
+            const finalEvents = await handle.getEvents();
+            expect2(finalEvents).toBeOneOf([
+              // Still active
+              ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
+              // Went to sleep and woke back up
+              [
+                "onStart",
+                "onBeforeConnect",
+                "onConnect",
+                "onDisconnect",
+                "onStart"
+              ]
+            ]);
+          },
+          // NOTE: High timeout required for Cloudflare Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
         );
       });
     });
@@ -868,7 +848,7 @@ function runActorConnTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-conn-state.ts
-import { describe as describe3, expect as expect3, test as test3, vi as vi2 } from "vitest";
+import { describe as describe3, expect as expect3, test as test3, vi as vi3 } from "vitest";
 function runActorConnStateTests(driverTestConfig) {
   describe3("Actor Connection State Tests", () => {
     describe3("Connection State Initialization", () => {
@@ -948,21 +928,57 @@ function runActorConnStateTests(driverTestConfig) {
       });
     });
     describe3("Connection Lifecycle", () => {
-      test3("should track connection and disconnection events", async (c) => {
+      test3.skipIf(
+        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
+      )("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.connStateActor.getOrCreate();
-        const conn = handle.connect();
+        const debugHandle = client.connStateActor.getOrCreate(void 0, {
+          params: { noCount: true }
+        });
+        const conn = client.connStateActor.getOrCreate().connect();
         const connState = await conn.getConnectionState();
-        const connectionIds = await conn.getConnectionIds();
-        expect3(connectionIds).toContain(connState.id);
-        const initialDisconnections = await conn.getDisconnectionCount();
+        await vi3.waitFor(async () => {
+          const connectionIds = await debugHandle.getConnectionIds();
+          expect3(connectionIds).toContain(connState.id);
+        });
+        await vi3.waitFor(async () => {
+          const disconnects = await debugHandle.getDisconnectionCount();
+          expect3(disconnects).toBe(0);
+        });
         await conn.dispose();
-        const newConn = handle.connect();
-        await vi2.waitFor(async () => {
-          const newDisconnections = await newConn.getDisconnectionCount();
-          expect3(newDisconnections).toBeGreaterThan(initialDisconnections);
+        await vi3.waitFor(
+          async () => {
+            console.log("disconnects before");
+            const disconnects = await debugHandle.getDisconnectionCount();
+            console.log("disconnects", disconnects);
+            expect3(disconnects).toBe(1);
+          },
+          // SSE takes a long time to disconnect on CF Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
+        );
+        const newConn = client.connStateActor.getOrCreate().connect();
+        await vi3.waitFor(async () => {
+          const connectionIds = await debugHandle.getConnectionIds();
+          console.log("conn ids", connectionIds);
+          expect3(connectionIds.length).toBe(1);
         });
         await newConn.dispose();
+        await vi3.waitFor(
+          async () => {
+            console.log("A");
+            const disconnects = await debugHandle.getDisconnectionCount();
+            console.log(`B ${disconnects}`);
+            expect3(disconnects).toBe(2);
+          },
+          // SSE takes a long time to disconnect on CF Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
+        );
       });
       test3("should update connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -993,14 +1009,16 @@ function runActorConnStateTests(driverTestConfig) {
         conn2.on("directMessage", (data) => {
           receivedMessages.push(data);
         });
-        const success = await conn1.sendToConnection(
-          state2.id,
-          "Hello from conn1"
-        );
-        expect3(success).toBe(true);
-        expect3(receivedMessages.length).toBe(1);
-        expect3(receivedMessages[0].from).toBe(state1.id);
-        expect3(receivedMessages[0].message).toBe("Hello from conn1");
+        await vi3.waitFor(async () => {
+          const success = await conn1.sendToConnection(
+            state2.id,
+            "Hello from conn1"
+          );
+          expect3(success).toBe(true);
+          expect3(receivedMessages.length).toBe(1);
+          expect3(receivedMessages[0].from).toBe(state1.id);
+          expect3(receivedMessages[0].message).toBe("Hello from conn1");
+        });
         await conn1.dispose();
         await conn2.dispose();
       });
@@ -1120,7 +1138,7 @@ var sleepWithLongRpc = actor({
     },
     longRunningRpc: async (c) => {
       c.log.info("starting long running rpc");
-      c.vars.longRunningResolve = Promise.withResolvers();
+      c.vars.longRunningResolve = promiseWithResolvers();
       c.broadcast("waiting");
       await c.vars.longRunningResolve.promise;
       c.log.info("finished long running rpc");
@@ -1447,7 +1465,6 @@ function runActorSleepTests(driverTestConfig) {
       expect5(counts.sleepCount).toBe(0);
       expect5(counts.startCount).toBe(1);
       ws.close();
-      await new Promise((resolve) => setTimeout(resolve, 100));
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
@@ -2515,117 +2532,214 @@ function runActorOnStateChangeTests(driverTestConfig) {
   });
 }
 
+// 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 describe14, expect as expect13, test as test13 } from "vitest";
+import { describe as describe15, expect as expect14, test as test14 } from "vitest";
 function runActorVarsTests(driverTestConfig) {
-  describe14("Actor Variables", () => {
-    describe14("Static vars", () => {
-      test13("should provide access to static vars", async (c) => {
+  describe15("Actor Variables", () => {
+    describe15("Static vars", () => {
+      test14("should provide access to static vars", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.staticVarActor.getOrCreate();
         const result = await instance.getVars();
-        expect13(result).toEqual({ counter: 42, name: "test-actor" });
+        expect14(result).toEqual({ counter: 42, name: "test-actor" });
         const name = await instance.getName();
-        expect13(name).toBe("test-actor");
+        expect14(name).toBe("test-actor");
       });
     });
-    describe14("Deep cloning of static vars", () => {
-      test13("should deep clone static vars between actor instances", async (c) => {
+    describe15("Deep cloning of static vars", () => {
+      test14("should deep clone static vars between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.nestedVarActor.getOrCreate(["instance1"]);
         const instance2 = client.nestedVarActor.getOrCreate(["instance2"]);
         const modifiedVars = await instance1.modifyNested();
-        expect13(modifiedVars.nested.value).toBe("modified");
-        expect13(modifiedVars.nested.array).toContain(4);
-        expect13(modifiedVars.nested.obj.key).toBe("new-value");
+        expect14(modifiedVars.nested.value).toBe("modified");
+        expect14(modifiedVars.nested.array).toContain(4);
+        expect14(modifiedVars.nested.obj.key).toBe("new-value");
         const instance2Vars = await instance2.getVars();
-        expect13(instance2Vars.nested.value).toBe("original");
-        expect13(instance2Vars.nested.array).toEqual([1, 2, 3]);
-        expect13(instance2Vars.nested.obj.key).toBe("value");
+        expect14(instance2Vars.nested.value).toBe("original");
+        expect14(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect14(instance2Vars.nested.obj.key).toBe("value");
       });
     });
-    describe14("createVars", () => {
-      test13("should support dynamic vars creation", async (c) => {
+    describe15("createVars", () => {
+      test14("should support dynamic vars creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.dynamicVarActor.getOrCreate();
         const vars = await instance.getVars();
-        expect13(vars).toHaveProperty("random");
-        expect13(vars).toHaveProperty("computed");
-        expect13(typeof vars.random).toBe("number");
-        expect13(typeof vars.computed).toBe("string");
-        expect13(vars.computed).toMatch(/^Actor-\d+$/);
+        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+$/);
       });
-      test13("should create different vars for different instances", async (c) => {
+      test14("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();
-        expect13(vars1.id).not.toBe(vars2.id);
+        expect14(vars1.id).not.toBe(vars2.id);
       });
     });
-    describe14("Driver Context", () => {
-      test13("should provide access to driver context", async (c) => {
+    describe15("Driver Context", () => {
+      test14("should provide access to driver context", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.driverCtxActor.getOrCreate();
         const vars = await instance.getVars();
-        expect13(vars).toHaveProperty("hasDriverCtx");
+        expect14(vars).toHaveProperty("hasDriverCtx");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/manager-driver.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 runManagerDriverTests(driverTestConfig) {
-  describe15("Manager Driver Tests", () => {
-    describe15("Client Connection Methods", () => {
-      test14("connect() - finds or creates a actor", async (c) => {
+  describe16("Manager Driver Tests", () => {
+    describe16("Client Connection Methods", () => {
+      test15("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);
-        expect14(count).toBe(5);
+        expect15(count).toBe(5);
         const counterB = client.counter.getOrCreate(["counter-b", "testing"]);
         await counterB.increment(10);
         const countB = await counterB.increment(0);
-        expect14(countB).toBe(10);
+        expect15(countB).toBe(10);
       });
-      test14("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+      test15("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);
-          expect14.fail("did not error on duplicate create");
+          expect15.fail("did not error on duplicate create");
         } catch (err) {
-          expect14(err.group).toBe("actor");
-          expect14(err.code).toBe("already_exists");
+          expect15(err.group).toBe("actor");
+          expect15(err.code).toBe("already_exists");
         }
         const count = await counter.increment(0);
-        expect14(count).toBe(5);
+        expect15(count).toBe(5);
       });
     });
-    describe15("Connection Options", () => {
-      test14("get without create prevents actor creation", async (c) => {
+    describe16("Connection Options", () => {
+      test15("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();
-          expect14.fail("did not error for get");
+          expect15.fail("did not error for get");
         } catch (err) {
-          expect14(err.group).toBe("actor");
-          expect14(err.code).toBe("not_found");
+          expect15(err.group).toBe("actor");
+          expect15(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);
-        expect14(count).toBe(3);
+        expect15(count).toBe(3);
       });
-      test14("connection params are passed to actors", async (c) => {
+      test15("connection params are passed to actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counter = client.counter.getOrCreate(void 0, {
           params: {
@@ -2636,20 +2750,20 @@ function runManagerDriverTests(driverTestConfig) {
         });
         await counter.increment(1);
         const count = await counter.increment(0);
-        expect14(count).toBe(1);
+        expect15(count).toBe(1);
       });
     });
-    describe15("Actor Creation & Retrieval", () => {
-      test14("creates and retrieves actors by ID", async (c) => {
+    describe16("Actor Creation & Retrieval", () => {
+      test15("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);
-        expect14(count).toBe(10);
+        expect15(count).toBe(10);
       });
-      test14("passes input to actor during creation", async (c) => {
+      test15("passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const testInput = {
           name: "test-actor",
@@ -2660,17 +2774,17 @@ function runManagerDriverTests(driverTestConfig) {
           input: testInput
         });
         const inputs = await actor2.getInputs();
-        expect14(inputs.initialInput).toEqual(testInput);
-        expect14(inputs.onCreateInput).toEqual(testInput);
+        expect15(inputs.initialInput).toEqual(testInput);
+        expect15(inputs.onCreateInput).toEqual(testInput);
       });
-      test14("input is undefined when not provided", async (c) => {
+      test15("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();
-        expect14(inputs.initialInput).toBeUndefined();
-        expect14(inputs.onCreateInput).toBeUndefined();
+        expect15(inputs.initialInput).toBeUndefined();
+        expect15(inputs.onCreateInput).toBeUndefined();
       });
-      test14("getOrCreate passes input to actor during creation", async (c) => {
+      test15("getOrCreate passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = [`input-test-${crypto.randomUUID()}`];
         const testInput = {
@@ -2682,16 +2796,16 @@ function runManagerDriverTests(driverTestConfig) {
           createWithInput: testInput
         });
         const inputs = await actor2.getInputs();
-        expect14(inputs.initialInput).toEqual(testInput);
-        expect14(inputs.onCreateInput).toEqual(testInput);
+        expect15(inputs.initialInput).toEqual(testInput);
+        expect15(inputs.onCreateInput).toEqual(testInput);
         const existingActor = client.inputActor.getOrCreate(uniqueKey);
         const existingInputs = await existingActor.getInputs();
-        expect14(existingInputs.initialInput).toEqual(testInput);
-        expect14(existingInputs.onCreateInput).toEqual(testInput);
+        expect15(existingInputs.initialInput).toEqual(testInput);
+        expect15(existingInputs.onCreateInput).toEqual(testInput);
       });
     });
-    describe15("Key Matching", () => {
-      test14("matches actors only with exactly the same keys", async (c) => {
+    describe16("Key Matching", () => {
+      test15("matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
           "counter-match",
@@ -2705,37 +2819,37 @@ function runManagerDriverTests(driverTestConfig) {
           "us-east"
         ]);
         const exactMatchCount = await exactMatchCounter.increment(0);
-        expect14(exactMatchCount).toBe(10);
+        expect15(exactMatchCount).toBe(10);
         const subsetMatchCounter = client.counter.getOrCreate([
           "counter-match",
           "test"
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
-        expect14(subsetMatchCount).toBe(0);
+        expect15(subsetMatchCount).toBe(0);
         const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
         const singleKeyCount = await singleKeyCounter.increment(0);
-        expect14(singleKeyCount).toBe(0);
+        expect15(singleKeyCount).toBe(0);
       });
-      test14("string key matches array with single string key", async (c) => {
+      test15("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);
         const arrayKeyCounter = client.counter.getOrCreate(["string-key-test"]);
         const count = await arrayKeyCounter.increment(0);
-        expect14(count).toBe(7);
+        expect15(count).toBe(7);
       });
-      test14("undefined key matches empty array key and no key", async (c) => {
+      test15("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);
-        expect14(emptyArrayCount).toBe(12);
+        expect15(emptyArrayCount).toBe(12);
         const noKeyCounter = client.counter.getOrCreate();
         const noKeyCount = await noKeyCounter.increment(0);
-        expect14(noKeyCount).toBe(12);
+        expect15(noKeyCount).toBe(12);
       });
-      test14("no keys does not match actors with keys", async (c) => {
+      test15("no keys does not match actors with keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const keyedCounter = client.counter.getOrCreate([
           "counter-with-keys",
@@ -2744,9 +2858,9 @@ function runManagerDriverTests(driverTestConfig) {
         await keyedCounter.increment(15);
         const noKeysCounter = client.counter.getOrCreate();
         const count = await noKeysCounter.increment(10);
-        expect14(count).toBe(10);
+        expect15(count).toBe(10);
       });
-      test14("actors with keys match actors with no keys", async (c) => {
+      test15("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);
@@ -2755,11 +2869,11 @@ function runManagerDriverTests(driverTestConfig) {
           "prod"
         ]);
         const keyedCount = await keyedCounter.increment(0);
-        expect14(keyedCount).toBe(0);
+        expect15(keyedCount).toBe(0);
       });
     });
-    describe15("Multiple Actor Instances", () => {
-      test14("creates multiple actor instances of the same type", async (c) => {
+    describe16("Multiple Actor Instances", () => {
+      test15("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"]);
@@ -2770,35 +2884,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"]);
-        expect14(await retrieved1.increment(0)).toBe(1);
-        expect14(await retrieved2.increment(0)).toBe(2);
-        expect14(await retrieved3.increment(0)).toBe(3);
+        expect15(await retrieved1.increment(0)).toBe(1);
+        expect15(await retrieved2.increment(0)).toBe(2);
+        expect15(await retrieved3.increment(0)).toBe(3);
       });
-      test14("handles default instance with no explicit ID", async (c) => {
+      test15("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);
-        expect14(count).toBe(5);
+        expect15(count).toBe(5);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http.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 runRawHttpTests(driverTestConfig) {
-  describe16("raw http", () => {
-    test15("should handle raw HTTP GET requests", async (c) => {
+  describe17("raw http", () => {
+    test16("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");
-      expect15(helloResponse.ok).toBe(true);
+      expect16(helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
-      expect15(helloData).toEqual({ message: "Hello from actor!" });
+      expect16(helloData).toEqual({ message: "Hello from actor!" });
     });
-    test15("should handle raw HTTP POST requests with echo", async (c) => {
+    test16("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 };
@@ -2809,22 +2923,22 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: JSON.stringify(testData)
       });
-      expect15(echoResponse.ok).toBe(true);
+      expect16(echoResponse.ok).toBe(true);
       const echoData = await echoResponse.json();
-      expect15(echoData).toEqual(testData);
+      expect16(echoData).toEqual(testData);
     });
-    test15("should track state across raw HTTP requests", async (c) => {
+    test16("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");
-      expect15(stateResponse.ok).toBe(true);
+      expect16(stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
-      expect15(stateData.requestCount).toBe(4);
+      expect16(stateData.requestCount).toBe(4);
     });
-    test15("should pass headers correctly", async (c) => {
+    test16("should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
@@ -2834,40 +2948,40 @@ function runRawHttpTests(driverTestConfig) {
       const response = await actor2.fetch("api/headers", {
         headers: customHeaders
       });
-      expect15(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const headers = await response.json();
-      expect15(headers["x-custom-header"]).toBe("test-value");
-      expect15(headers["x-another-header"]).toBe("another-value");
+      expect16(headers["x-custom-header"]).toBe("test-value");
+      expect16(headers["x-another-header"]).toBe("another-value");
     });
-    test15("should return 404 for unhandled paths", async (c) => {
+    test16("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");
-      expect15(response.ok).toBe(false);
-      expect15(response.status).toBe(404);
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(404);
     });
-    test15("should return 404 when no onFetch handler defined", async (c) => {
+    test16("should return 404 when no onFetch handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpNoHandlerActor.getOrCreate(["no-handler"]);
       const response = await actor2.fetch("api/anything");
-      expect15(response.ok).toBe(false);
-      expect15(response.status).toBe(404);
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(404);
     });
-    test15("should return 500 error when onFetch returns void", async (c) => {
+    test16("should return 500 error when onFetch returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpVoidReturnActor.getOrCreate(["void-return"]);
       const response = await actor2.fetch("api/anything");
-      expect15(response.ok).toBe(false);
-      expect15(response.status).toBe(500);
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(500);
       try {
         const errorData = await response.json();
-        expect15(errorData.message).toContain(
+        expect16(errorData.message).toContain(
           "onFetch handler must return a Response"
         );
       } catch {
       }
     });
-    test15("should handle different HTTP methods", async (c) => {
+    test16("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"];
@@ -2877,17 +2991,17 @@ function runRawHttpTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "POST") {
-          expect15(response.ok).toBe(true);
+          expect16(response.ok).toBe(true);
           const data = await response.json();
-          expect15(data).toEqual({ method });
+          expect16(data).toEqual({ method });
         } else if (method === "GET") {
-          expect15(response.status).toBe(404);
+          expect16(response.status).toBe(404);
         } else {
-          expect15(response.status).toBe(404);
+          expect16(response.status).toBe(404);
         }
       }
     });
-    test15("should handle binary data", async (c) => {
+    test16("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]);
@@ -2898,82 +3012,82 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: binaryData
       });
-      expect15(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const responseBuffer = await response.arrayBuffer();
       const responseArray = new Uint8Array(responseBuffer);
-      expect15(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+      expect16(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
     });
-    test15("should work with Hono router using createVars", async (c) => {
+    test16("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("/");
-      expect15(rootResponse.ok).toBe(true);
+      expect16(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect15(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      expect16(rootData).toEqual({ message: "Welcome to Hono actor!" });
       const usersResponse = await actor2.fetch("/users");
-      expect15(usersResponse.ok).toBe(true);
+      expect16(usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
-      expect15(users).toEqual([
+      expect16(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
       const userResponse = await actor2.fetch("/users/1");
-      expect15(userResponse.ok).toBe(true);
+      expect16(userResponse.ok).toBe(true);
       const user = await userResponse.json();
-      expect15(user).toEqual({ id: 1, name: "Alice" });
+      expect16(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)
       });
-      expect15(createResponse.ok).toBe(true);
-      expect15(createResponse.status).toBe(201);
+      expect16(createResponse.ok).toBe(true);
+      expect16(createResponse.status).toBe(201);
       const createdUser = await createResponse.json();
-      expect15(createdUser).toEqual({ id: 3, name: "Charlie" });
+      expect16(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)
       });
-      expect15(updateResponse.ok).toBe(true);
+      expect16(updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
-      expect15(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      expect16(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
       const deleteResponse = await actor2.fetch("/users/2", {
         method: "DELETE"
       });
-      expect15(deleteResponse.ok).toBe(true);
+      expect16(deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
-      expect15(deleteResult).toEqual({ message: "User 2 deleted" });
+      expect16(deleteResult).toEqual({ message: "User 2 deleted" });
       const notFoundResponse = await actor2.fetch("/api/unknown");
-      expect15(notFoundResponse.ok).toBe(false);
-      expect15(notFoundResponse.status).toBe(404);
+      expect16(notFoundResponse.ok).toBe(false);
+      expect16(notFoundResponse.status).toBe(404);
     });
-    test15("should handle paths with and without leading slashes", async (c) => {
+    test16("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");
-      expect15(responseWithoutSlash.ok).toBe(true);
+      expect16(responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
-      expect15(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      expect16(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
       const responseWithSlash = await actor2.fetch("/api/hello");
-      expect15(responseWithSlash.ok).toBe(true);
+      expect16(responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
-      expect15(dataWithSlash).toEqual({ message: "Hello from actor!" });
+      expect16(dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
-    test15("should not create double slashes in request URLs", async (c) => {
+    test16("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");
-      expect15(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect15(data).toEqual([
+      expect16(data).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test15("should handle forwarded requests correctly without double slashes", async (c) => {
+    test16("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";
@@ -2982,14 +3096,14 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor2.fetch(truncatedPath, newRequest);
-      expect15(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const users = await response.json();
-      expect15(users).toEqual([
+      expect16(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test15("example fix: should properly forward requests using just Request object", async (c) => {
+    test16("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";
@@ -2998,11 +3112,11 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor2.fetch(newRequest);
-      expect15(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const user = await response.json();
-      expect15(user).toEqual({ id: 1, name: "Alice" });
+      expect16(user).toEqual({ id: 1, name: "Alice" });
     });
-    test15("should support standard fetch API with URL and Request objects", async (c) => {
+    test16("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");
@@ -3011,18 +3125,18 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
       });
-      expect15(urlResponse.ok).toBe(true);
+      expect16(urlResponse.ok).toBe(true);
       const urlData = await urlResponse.json();
-      expect15(urlData).toEqual({ from: "URL object" });
+      expect16(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);
-      expect15(requestResponse.ok).toBe(true);
+      expect16(requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
-      expect15(requestData).toEqual({ from: "Request object" });
+      expect16(requestData).toEqual({ from: "Request object" });
       const request2 = new Request("http://example.com/api/headers", {
         method: "GET",
         headers: { "X-Original": "request-header" }
@@ -3030,19 +3144,19 @@ function runRawHttpTests(driverTestConfig) {
       const overrideResponse = await actor2.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
-      expect15(overrideResponse.ok).toBe(true);
+      expect16(overrideResponse.ok).toBe(true);
       const headers = await overrideResponse.json();
-      expect15(headers["x-override"]).toBe("init-header");
-      expect15(headers["x-original"]).toBe("request-header");
+      expect16(headers["x-override"]).toBe("init-header");
+      expect16(headers["x-original"]).toBe("request-header");
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http-request-properties.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 runRawHttpRequestPropertiesTests(driverTestConfig) {
-  describe17("raw http request properties", () => {
-    test16("should pass all Request properties correctly to onFetch", async (c) => {
+  describe18("raw http request properties", () => {
+    test17("should pass all Request properties correctly to onFetch", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/path?foo=bar&baz=qux", {
@@ -3054,33 +3168,33 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify({ test: "data" })
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.url).toContain("/test/path?foo=bar&baz=qux");
-      expect16(data.pathname).toBe("/test/path");
-      expect16(data.search).toBe("?foo=bar&baz=qux");
-      expect16(data.searchParams).toEqual({
+      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({
         foo: "bar",
         baz: "qux"
       });
-      expect16(data.method).toBe("POST");
-      expect16(data.headers["content-type"]).toBe("application/json");
-      expect16(data.headers["x-custom-header"]).toBe("custom-value");
-      expect16(data.headers["authorization"]).toBe("Bearer test-token");
-      expect16(data.body).toEqual({ test: "data" });
+      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" });
     });
-    test16("should handle GET requests with no body", async (c) => {
+    test17("should handle GET requests with no body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/get", {
         method: "GET"
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.method).toBe("GET");
-      expect16(data.body).toBeNull();
+      expect17(data.method).toBe("GET");
+      expect17(data.body).toBeNull();
     });
-    test16("should handle different content types", async (c) => {
+    test17("should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const formData = new URLSearchParams();
@@ -3093,12 +3207,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: formData.toString()
       });
-      expect16(formResponse.ok).toBe(true);
+      expect17(formResponse.ok).toBe(true);
       const formResult = await formResponse.json();
-      expect16(formResult.headers["content-type"]).toBe(
+      expect17(formResult.headers["content-type"]).toBe(
         "application/x-www-form-urlencoded"
       );
-      expect16(formResult.bodyText).toBe("field1=value1&field2=value2");
+      expect17(formResult.bodyText).toBe("field1=value1&field2=value2");
       const textResponse = await actor2.fetch("test/text", {
         method: "POST",
         headers: {
@@ -3106,12 +3220,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: "Hello, World!"
       });
-      expect16(textResponse.ok).toBe(true);
+      expect17(textResponse.ok).toBe(true);
       const textResult = await textResponse.json();
-      expect16(textResult.headers["content-type"]).toBe("text/plain");
-      expect16(textResult.bodyText).toBe("Hello, World!");
+      expect17(textResult.headers["content-type"]).toBe("text/plain");
+      expect17(textResult.bodyText).toBe("Hello, World!");
     });
-    test16("should preserve all header casing and values", async (c) => {
+    test17("should preserve all header casing and values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/headers", {
@@ -3123,34 +3237,34 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           "X-Request-ID": "12345"
         }
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.headers["accept"]).toBe("application/json");
-      expect16(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
-      expect16(data.headers["cache-control"]).toBe("no-cache");
-      expect16(data.headers["user-agent"]).toBeTruthy();
-      expect16(data.headers["x-request-id"]).toBe("12345");
+      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");
     });
-    test16("should handle empty and special URL paths", async (c) => {
+    test17("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("");
-      expect16(rootResponse.ok).toBe(true);
+      expect17(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect16(rootData.pathname).toBe("/");
+      expect17(rootData.pathname).toBe("/");
       const specialResponse = await actor2.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
-      expect16(specialResponse.ok).toBe(true);
+      expect17(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect16(specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
+      expect17(specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
       const fragmentResponse = await actor2.fetch("test/path#fragment");
-      expect16(fragmentResponse.ok).toBe(true);
+      expect17(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
-      expect16(fragmentData.pathname).toBe("/test/path");
-      expect16(fragmentData.hash).toBe("");
+      expect17(fragmentData.pathname).toBe("/test/path");
+      expect17(fragmentData.hash).toBe("");
     });
-    test16("should handle request properties for all HTTP methods", async (c) => {
+    test17("should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const methods = [
@@ -3169,33 +3283,33 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "HEAD") {
-          expect16(response.status).toBe(200);
+          expect17(response.status).toBe(200);
           const text = await response.text();
-          expect16(text).toBe("");
+          expect17(text).toBe("");
         } else if (method === "OPTIONS") {
-          expect16(response.status).toBe(204);
+          expect17(response.status).toBe(204);
           const text = await response.text();
-          expect16(text).toBe("");
+          expect17(text).toBe("");
         } else {
-          expect16(response.ok).toBe(true);
+          expect17(response.ok).toBe(true);
           const data = await response.json();
-          expect16(data.method).toBe(method);
+          expect17(data.method).toBe(method);
         }
       }
     });
-    test16("should handle complex query parameters", async (c) => {
+    test17("should handle complex query parameters", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.searchParams.key).toBe("value2");
-      expect16(data.searchParams["array[]"]).toBe("2");
-      expect16(data.searchParams["nested[prop]"]).toBe("val");
+      expect17(data.searchParams.key).toBe("value2");
+      expect17(data.searchParams["array[]"]).toBe("2");
+      expect17(data.searchParams["nested[prop]"]).toBe("val");
     });
-    test16("should handle multipart form data", async (c) => {
+    test17("should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const boundary = "----RivetKitBoundary";
@@ -3217,23 +3331,23 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.headers["content-type"]).toContain("multipart/form-data");
-      expect16(data.bodyText).toContain("field1");
-      expect16(data.bodyText).toContain("value1");
+      expect17(data.headers["content-type"]).toContain("multipart/form-data");
+      expect17(data.bodyText).toContain("field1");
+      expect17(data.bodyText).toContain("value1");
     });
-    test16("should handle very long URLs", async (c) => {
+    test17("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}`);
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.searchParams.param).toBe(longValue);
-      expect16(data.search.length).toBeGreaterThan(1e3);
+      expect17(data.searchParams.param).toBe(longValue);
+      expect17(data.search.length).toBeGreaterThan(1e3);
     });
-    test16("should handle large request bodies", async (c) => {
+    test17("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const largeArray = new Array(1e4).fill({
@@ -3248,22 +3362,22 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify(largeArray)
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.body).toHaveLength(1e4);
+      expect17(data.body).toHaveLength(1e4);
     });
-    test16("should handle missing content-type header", async (c) => {
+    test17("should handle missing content-type header", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/no-content-type", {
         method: "POST",
         body: "plain text without content-type"
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.bodyText).toBe("plain text without content-type");
+      expect17(data.bodyText).toBe("plain text without content-type");
     });
-    test16("should handle empty request body", async (c) => {
+    test17("should handle empty request body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/empty", {
@@ -3273,12 +3387,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: ""
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.body).toBeNull();
-      expect16(data.bodyText).toBe("");
+      expect17(data.body).toBeNull();
+      expect17(data.bodyText).toBe("");
     });
-    test16("should handle custom HTTP methods", async (c) => {
+    test17("should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       try {
@@ -3287,12 +3401,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         });
         if (response.ok) {
           const data = await response.json();
-          expect16(data.method).toBe("CUSTOM");
+          expect17(data.method).toBe("CUSTOM");
         }
       } catch (error) {
       }
     });
-    test16("should handle cookies in headers", async (c) => {
+    test17("should handle cookies in headers", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch("test/cookies", {
@@ -3300,25 +3414,25 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
       });
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.headers.cookie).toBe(
+      expect17(data.headers.cookie).toBe(
         "session=abc123; user=test; preferences=dark_mode"
       );
     });
-    test16("should handle URL encoding properly", async (c) => {
+    test17("should handle URL encoding properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const response = await actor2.fetch(
         "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
       );
-      expect16(response.ok).toBe(true);
+      expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data.searchParams.special).toBe(" !@#$%^&");
-      expect16(data.searchParams.unicode).toBe("\u2713");
-      expect16(data.searchParams.email).toBe("test@example.com");
+      expect17(data.searchParams.special).toBe(" !@#$%^&");
+      expect17(data.searchParams.unicode).toBe("\u2713");
+      expect17(data.searchParams.email).toBe("test@example.com");
     });
-    test16("should handle concurrent requests maintaining separate contexts", async (c) => {
+    test17("should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const requests = [
@@ -3340,24 +3454,24 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const results = await Promise.all(
         responses.map((r) => r.json())
       );
-      expect16(results[0].searchParams.id).toBe("1");
-      expect16(results[0].method).toBe("POST");
-      expect16(results[0].body).toEqual({ request: 1 });
-      expect16(results[1].searchParams.id).toBe("2");
-      expect16(results[1].method).toBe("PUT");
-      expect16(results[1].body).toEqual({ request: 2 });
-      expect16(results[2].searchParams.id).toBe("3");
-      expect16(results[2].method).toBe("DELETE");
-      expect16(results[2].body).toBeNull();
+      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();
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-websocket.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 runRawWebSocketTests(driverTestConfig) {
-  describe18("raw websocket", () => {
-    test17("should establish raw WebSocket connection", async (c) => {
+  describe19("raw websocket", () => {
+    test18("should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
       const ws = await actor2.websocket();
@@ -3384,11 +3498,11 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect17(welcomeMessage.type).toBe("welcome");
-      expect17(welcomeMessage.connectionCount).toBe(1);
+      expect18(welcomeMessage.type).toBe("welcome");
+      expect18(welcomeMessage.connectionCount).toBe(1);
       ws.close();
     });
-    test17("should echo messages", async (c) => {
+    test18("should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
       const ws = await actor2.websocket();
@@ -3414,10 +3528,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect17(echoMessage).toEqual(testMessage);
+      expect18(echoMessage).toEqual(testMessage);
       ws.close();
     });
-    test17("should handle ping/pong protocol", async (c) => {
+    test18("should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
       const ws = await actor2.websocket();
@@ -3441,11 +3555,11 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect17(pongMessage.type).toBe("pong");
-      expect17(pongMessage.timestamp).toBeDefined();
+      expect18(pongMessage.type).toBe("pong");
+      expect18(pongMessage.timestamp).toBeDefined();
       ws.close();
     });
-    test17("should track stats across connections", async (c) => {
+    test18("should track stats across connections", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.websocket();
@@ -3485,15 +3599,15 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws1.send(JSON.stringify({ type: "getStats" }));
       const stats = await statsPromise;
-      expect17(stats.connectionCount).toBe(2);
-      expect17(stats.messageCount).toBe(4);
+      expect18(stats.connectionCount).toBe(2);
+      expect18(stats.messageCount).toBe(4);
       const actionStats = await actor1.getStats();
-      expect17(actionStats.connectionCount).toBe(2);
-      expect17(actionStats.messageCount).toBe(4);
+      expect18(actionStats.connectionCount).toBe(2);
+      expect18(actionStats.messageCount).toBe(4);
       ws1.close();
       ws2.close();
     });
-    test17("should handle binary data", async (c) => {
+    test18("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketBinaryActor.getOrCreate(["binary"]);
       const ws = await actor2.websocket();
@@ -3522,7 +3636,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const smallData = new Uint8Array([1, 2, 3, 4, 5]);
       ws.send(smallData);
       const smallReversed = await receiveBinaryMessage();
-      expect17(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
+      expect18(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;
@@ -3530,11 +3644,11 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        expect17(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+        expect18(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
       }
       ws.close();
     });
-    test17("should work with custom paths", async (c) => {
+    test18("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");
@@ -3554,33 +3668,10 @@ function runRawWebSocketTests(driverTestConfig) {
           { once: true }
         );
       });
-      expect17(welcomeMessage.type).toBe("welcome");
-      ws.close();
-    });
-    test17("should pass connection parameters through subprotocols", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const testParams = { userId: "test123", role: "admin" };
-      const actor2 = client.rawWebSocketActor.getOrCreate(["params"], {
-        params: testParams
-      });
-      const ws = await actor2.websocket();
-      await new Promise((resolve) => {
-        ws.addEventListener("open", () => resolve(), { once: true });
-      });
-      ws.send(JSON.stringify({ type: "getAuthData" }));
-      const response = await new Promise((resolve, reject) => {
-        ws.addEventListener("message", (event) => {
-          const data = JSON.parse(event.data);
-          if (data.type === "authData") {
-            resolve(data);
-          }
-        });
-        ws.addEventListener("close", reject);
-      });
-      expect17(response).toBeDefined();
+      expect18(welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    test17("should handle connection close properly", async (c) => {
+    test18("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();
@@ -3591,7 +3682,7 @@ function runRawWebSocketTests(driverTestConfig) {
         });
       }
       const initialStats = await actor2.getStats();
-      expect17(initialStats.connectionCount).toBe(1);
+      expect18(initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve) => {
         ws.addEventListener("close", () => resolve(), { once: true });
       });
@@ -3605,9 +3696,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect17(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect18(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test17("should properly handle onWebSocket open and close events", async (c) => {
+    test18("should properly handle onWebSocket open and close events", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["open-close-test"]);
       const ws1 = await actor2.websocket();
@@ -3625,8 +3716,8 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws1.addEventListener("close", reject);
       });
-      expect17(welcome1.type).toBe("welcome");
-      expect17(welcome1.connectionCount).toBe(1);
+      expect18(welcome1.type).toBe("welcome");
+      expect18(welcome1.connectionCount).toBe(1);
       const ws2 = await actor2.websocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
@@ -3642,10 +3733,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws2.addEventListener("close", reject);
       });
-      expect17(welcome2.type).toBe("welcome");
-      expect17(welcome2.connectionCount).toBe(2);
+      expect18(welcome2.type).toBe("welcome");
+      expect18(welcome2.connectionCount).toBe(2);
       const midStats = await actor2.getStats();
-      expect17(midStats.connectionCount).toBe(2);
+      expect18(midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve) => {
         ws1.addEventListener("close", () => resolve(), { once: true });
@@ -3658,7 +3749,7 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect17(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      expect18(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
       await new Promise((resolve) => {
         ws2.addEventListener("close", () => resolve(), { once: true });
@@ -3671,9 +3762,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect17(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect18(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test17("should handle query parameters in websocket paths", async (c) => {
+    test18("should handle query parameters in websocket paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["query-params"]);
       const ws = await actor2.websocket("api/v1/stream?token=abc123&user=test");
@@ -3692,19 +3783,19 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect17(requestInfo.url).toContain("api/v1/stream");
-      expect17(requestInfo.url).toContain("token=abc123");
-      expect17(requestInfo.url).toContain("user=test");
+      expect18(requestInfo.url).toContain("api/v1/stream");
+      expect18(requestInfo.url).toContain("token=abc123");
+      expect18(requestInfo.url).toContain("user=test");
       ws.close();
     });
   });
 }
 
 // src/driver-test-suite/tests/request-access.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 runRequestAccessTests(driverTestConfig) {
-  describe19("Request Access in Lifecycle Hooks", () => {
-    test18("should have access to request object in onBeforeConnect and createConnState", async (c) => {
+  describe20("Request Access in Lifecycle Hooks", () => {
+    test19("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"], {
         params: { trackRequest: true }
@@ -3712,19 +3803,19 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect18(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect18(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
-        expect18(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        expect18(requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
-        expect18(requestInfo.createConnState.hasRequest).toBe(true);
-        expect18(requestInfo.createConnState.requestUrl).toBeDefined();
-        expect18(requestInfo.createConnState.requestMethod).toBeDefined();
-        expect18(requestInfo.createConnState.requestHeaders).toBeDefined();
+        expect19(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect19(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect19(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect19(requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
+        expect19(requestInfo.createConnState.hasRequest).toBe(true);
+        expect19(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect19(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect19(requestInfo.createConnState.requestHeaders).toBeDefined();
       } else {
       }
       await connection.dispose();
     });
-    test18("should not have request when trackRequest is false", async (c) => {
+    test19("should not have request when trackRequest is false", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-no-request"],
@@ -3734,21 +3825,21 @@ function runRequestAccessTests(driverTestConfig) {
       );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
-      expect18(requestInfo.onBeforeConnect.hasRequest).toBe(false);
-      expect18(requestInfo.onBeforeConnect.requestUrl).toBeNull();
-      expect18(requestInfo.onBeforeConnect.requestMethod).toBeNull();
-      expect18(
+      expect19(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect19(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect19(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect19(
         Object.keys(requestInfo.onBeforeConnect.requestHeaders)
       ).toHaveLength(0);
-      expect18(requestInfo.createConnState.hasRequest).toBe(false);
-      expect18(requestInfo.createConnState.requestUrl).toBeNull();
-      expect18(requestInfo.createConnState.requestMethod).toBeNull();
-      expect18(
+      expect19(requestInfo.createConnState.hasRequest).toBe(false);
+      expect19(requestInfo.createConnState.requestUrl).toBeNull();
+      expect19(requestInfo.createConnState.requestMethod).toBeNull();
+      expect19(
         Object.keys(requestInfo.createConnState.requestHeaders)
       ).toHaveLength(0);
       await connection.dispose();
     });
-    test18("should capture request headers and method", async (c) => {
+    test19("should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(["test-headers"], {
         params: { trackRequest: true }
@@ -3756,18 +3847,18 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect18(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect18(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
-        expect18(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
-        expect18(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
-        expect18(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+        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(
           "object"
         );
-        expect18(requestInfo.createConnState.hasRequest).toBe(true);
-        expect18(requestInfo.createConnState.requestMethod).toBeTruthy();
-        expect18(requestInfo.createConnState.requestUrl).toBeTruthy();
-        expect18(requestInfo.createConnState.requestHeaders).toBeTruthy();
-        expect18(typeof requestInfo.createConnState.requestHeaders).toBe(
+        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(
           "object"
         );
       } else {
@@ -3784,16 +3875,19 @@ function runDriverTests(driverTestConfigPartial) {
       ...driverTestConfigPartial,
       clientType
     };
-    describe20(`client type (${clientType})`, () => {
+    describe21(`client type (${clientType})`, () => {
+      var _a;
       runActorDriverTests(driverTestConfig);
       runManagerDriverTests(driverTestConfig);
-      for (const transport of ["websocket", "sse"]) {
-        describe20(`transport (${transport})`, () => {
+      const transports = ((_a = driverTestConfig.skip) == null ? void 0 : _a.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 });
         });
@@ -3845,11 +3939,12 @@ async function createTestRuntime(registryPath, driverFactory) {
       }
     });
     const managerDriver = driver.manager(registry.config, config);
+    configureInspectorAccessToken(config, managerDriver);
     const { router } = createManagerRouter(
       registry.config,
       config,
       managerDriver,
-      false
+      void 0
     );
     const nodeWebSocket = createNodeWebSocket({ app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
@@ -3859,7 +3954,7 @@ async function createTestRuntime(registryPath, driverFactory) {
       hostname: "127.0.0.1",
       port
     });
-    invariant2(
+    invariant(
       nodeWebSocket.injectWebSocket !== void 0,
       "should have injectWebSocket"
     );