rivetkit 2.0.20 → 2.0.21

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

@@ -1,30 +1,30 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunk2I6L3VROcjs = require('../chunk-2I6L3VRO.cjs');
+var _chunkJTIBPF7Ncjs = require('../chunk-JTIBPF7N.cjs');
 
 
 
-var _chunk2S7HJMMYcjs = require('../chunk-2S7HJMMY.cjs');
+var _chunkM5BHNJHBcjs = require('../chunk-M5BHNJHB.cjs');
 
 
 
 
-var _chunkDUOTOMP7cjs = require('../chunk-DUOTOMP7.cjs');
+var _chunkZNWE3XBTcjs = require('../chunk-ZNWE3XBT.cjs');
 
 
-var _chunkG6JGHCG4cjs = require('../chunk-G6JGHCG4.cjs');
+var _chunkO4GUKGK4cjs = require('../chunk-O4GUKGK4.cjs');
 
 
 
-var _chunkJZD6FEOEcjs = require('../chunk-JZD6FEOE.cjs');
-require('../chunk-ZODINJWN.cjs');
+var _chunkLMJHBF26cjs = require('../chunk-LMJHBF26.cjs');
+require('../chunk-65SAIRRY.cjs');
 
 
-var _chunkKKRR7DSGcjs = require('../chunk-KKRR7DSG.cjs');
+var _chunkLWGCMELPcjs = require('../chunk-LWGCMELP.cjs');
 
 
 
-var _chunkFYP3TZXDcjs = require('../chunk-FYP3TZXD.cjs');
+var _chunkFDJ3AVNBcjs = require('../chunk-FDJ3AVNB.cjs');
 
 
 
@@ -35,13 +35,13 @@ var _chunkFYP3TZXDcjs = require('../chunk-FYP3TZXD.cjs');
 
 
 
-var _chunkPV22ZBDEcjs = require('../chunk-PV22ZBDE.cjs');
+var _chunkJKOUXDK6cjs = require('../chunk-JKOUXDK6.cjs');
 
 
-var _chunkRJVSNJO7cjs = require('../chunk-RJVSNJO7.cjs');
+var _chunkHN7UXCYQcjs = require('../chunk-HN7UXCYQ.cjs');
 
 
-var _chunkKUZWEM23cjs = require('../chunk-KUZWEM23.cjs');
+var _chunkELDFBXDVcjs = require('../chunk-ELDFBXDV.cjs');
 
 
 
@@ -56,7 +56,7 @@ var _vitest = require('vitest');
 
 // src/driver-test-suite/log.ts
 function logger() {
-  return _chunkRJVSNJO7cjs.getLogger.call(void 0, "test-suite");
+  return _chunkHN7UXCYQcjs.getLogger.call(void 0, "test-suite");
 }
 
 // src/driver-test-suite/tests/action-features.ts
@@ -70,14 +70,22 @@ var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
 function createTestInlineClientDriver(endpoint, encoding, transport) {
   return {
     getForId(input) {
-      return makeInlineRequest(endpoint, encoding, transport, "getForId", [
-        input
-      ]);
+      return makeInlineRequest(
+        endpoint,
+        encoding,
+        transport,
+        "getForId",
+        [input]
+      );
     },
     getWithKey(input) {
-      return makeInlineRequest(endpoint, encoding, transport, "getWithKey", [
-        input
-      ]);
+      return makeInlineRequest(
+        endpoint,
+        encoding,
+        transport,
+        "getWithKey",
+        [input]
+      );
     },
     getOrCreateWithKey(input) {
       return makeInlineRequest(
@@ -89,9 +97,13 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       );
     },
     createActor(input) {
-      return makeInlineRequest(endpoint, encoding, transport, "createActor", [
-        input
-      ]);
+      return makeInlineRequest(
+        endpoint,
+        encoding,
+        transport,
+        "createActor",
+        [input]
+      );
     },
     async sendRequest(actorId, actorRequest) {
       var _a;
@@ -105,9 +117,13 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
         path: pathWithQuery
       });
       const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
-      logger().debug({ msg: "rewriting http url", from: oldUrl, to: url });
+      logger().debug({
+        msg: "rewriting http url",
+        from: oldUrl,
+        to: url
+      });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkPV22ZBDEcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkJKOUXDK6cjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -123,7 +139,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkJZD6FEOEcjs.ActorError)(
+              throw new (0, _chunkLMJHBF26cjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -131,7 +147,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkJZD6FEOEcjs.ActorError)) {
+          if (!(e instanceof _chunkLMJHBF26cjs.ActorError)) {
             return response;
           }
           throw e;
@@ -140,7 +156,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params, connId, connToken) {
-      const WebSocket2 = await _chunkKKRR7DSGcjs.importWebSocket.call(void 0, );
+      const WebSocket2 = await _chunkLWGCMELPcjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
@@ -153,16 +169,16 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
       const protocols = [];
-      protocols.push(`${_chunkPV22ZBDEcjs.WS_PROTOCOL_TARGET}actor`);
-      protocols.push(`${_chunkPV22ZBDEcjs.WS_PROTOCOL_ACTOR}${actorId}`);
-      protocols.push(`${_chunkPV22ZBDEcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
-      protocols.push(`${_chunkPV22ZBDEcjs.WS_PROTOCOL_TRANSPORT}${transport}`);
+      protocols.push(`${_chunkJKOUXDK6cjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(`${_chunkJKOUXDK6cjs.WS_PROTOCOL_ACTOR}${actorId}`);
+      protocols.push(`${_chunkJKOUXDK6cjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkJKOUXDK6cjs.WS_PROTOCOL_TRANSPORT}${transport}`);
       protocols.push(
-        `${_chunkPV22ZBDEcjs.WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunkJKOUXDK6cjs.WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunkPV22ZBDEcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunkJKOUXDK6cjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
       const ws = new WebSocket2(finalWsUrl, protocols);
@@ -518,7 +534,9 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
     duplex: "half"
   });
   if (!response.ok) {
-    throw new Error(`Failed to call inline ${method}: ${response.statusText}`);
+    throw new Error(
+      `Failed to call inline ${method}: ${response.statusText}`
+    );
   }
   const buffer = await response.arrayBuffer();
   const callResponse = cbor.decode(
@@ -527,14 +545,14 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkJZD6FEOEcjs.ActorError)(
+    throw new (0, _chunkLMJHBF26cjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkPV22ZBDEcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkJKOUXDK6cjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -549,7 +567,7 @@ async function setupDriverTest(c, driverTestConfig) {
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkG6JGHCG4cjs.createClient.call(void 0, {
+    client = _chunkO4GUKGK4cjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -564,13 +582,13 @@ async function setupDriverTest(c, driverTestConfig) {
       encoding,
       transport
     );
-    const runConfig = _chunkFYP3TZXDcjs.RunnerConfigSchema.parse({
+    const runConfig = _chunkFDJ3AVNBcjs.RunnerConfigSchema.parse({
       transport,
       encoding
     });
-    client = _chunkJZD6FEOEcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkLMJHBF26cjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkPV22ZBDEcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkJKOUXDK6cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -650,7 +668,9 @@ function runActionFeaturesTests(driverTestConfig) {
           await instance.asyncWithError(true);
           _vitest.expect.fail("did not error");
         } catch (error) {
-          _vitest.expect.call(void 0, error.message).toBe("Intentional error");
+          _vitest.expect.call(void 0, error.message).toBe(
+            "Intentional error"
+          );
         }
       });
       _vitest.test.call(void 0, "should handle promises returned from actions correctly", async (c) => {
@@ -697,7 +717,9 @@ function runActorConnTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should connect using .getOrCreate().connect()", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.counter.getOrCreate(["test-get-or-create"]);
+        const handle = client.counter.getOrCreate([
+          "test-get-or-create"
+        ]);
         const connection = handle.connect();
         const count = await connection.increment(7);
         _vitest.expect.call(void 0, count).toBe(7);
@@ -715,7 +737,9 @@ function runActorConnTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Event Communication", () => {
       _vitest.test.call(void 0, "should mix RPC calls and WebSocket events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
+        const handle = client.counter.getOrCreate([
+          "test-mixed-rpc-ws"
+        ]);
         const connection = handle.connect();
         const receivedEvents = [];
         connection.on("newCount", (count) => {
@@ -773,9 +797,12 @@ function runActorConnTests(driverTestConfig) {
         const handle = client.counter.getOrCreate(["test-unsubscribe"]);
         const connection = handle.connect();
         const receivedEvents = [];
-        const unsubscribe = connection.on("newCount", (count) => {
-          receivedEvents.push(count);
-        });
+        const unsubscribe = connection.on(
+          "newCount",
+          (count) => {
+            receivedEvents.push(count);
+          }
+        );
         await _vitest.vi.waitFor(async () => {
           await connection.setCount(5);
           _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
@@ -789,12 +816,18 @@ function runActorConnTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Connection Parameters", () => {
       _vitest.test.call(void 0, "should pass connection parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle1 = client.counterWithParams.getOrCreate(["test-params"], {
-          params: { name: "user1" }
-        });
-        const handle2 = client.counterWithParams.getOrCreate(["test-params"], {
-          params: { name: "user2" }
-        });
+        const handle1 = client.counterWithParams.getOrCreate(
+          ["test-params"],
+          {
+            params: { name: "user1" }
+          }
+        );
+        const handle2 = client.counterWithParams.getOrCreate(
+          ["test-params"],
+          {
+            params: { name: "user2" }
+          }
+        );
         const conn1 = handle1.connect();
         const conn2 = handle2.connect();
         await conn1.getInitializers();
@@ -819,7 +852,11 @@ function runActorConnTests(driverTestConfig) {
         );
         const connection = connHandle.connect();
         const events = await connection.getEvents();
-        _vitest.expect.call(void 0, events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
+        _vitest.expect.call(void 0, events).toEqual([
+          "onStart",
+          "onBeforeConnect",
+          "onConnect"
+        ]);
         await connection.dispose();
         await _vitest.vi.waitFor(
           async () => {
@@ -829,7 +866,12 @@ function runActorConnTests(driverTestConfig) {
             const finalEvents = await handle.getEvents();
             _vitest.expect.call(void 0, finalEvents).toBeOneOf([
               // Still active
-              ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
+              [
+                "onStart",
+                "onBeforeConnect",
+                "onConnect",
+                "onDisconnect"
+              ],
               // Went to sleep and woke back up
               [
                 "onStart",
@@ -936,9 +978,12 @@ function runActorConnStateTests(driverTestConfig) {
         driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
       )("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const debugHandle = client.connStateActor.getOrCreate(void 0, {
-          params: { noCount: true }
-        });
+        const debugHandle = client.connStateActor.getOrCreate(
+          void 0,
+          {
+            params: { noCount: true }
+          }
+        );
         const conn = client.connStateActor.getOrCreate().connect();
         const connState = await conn.getConnectionState();
         await _vitest.vi.waitFor(async () => {
@@ -1021,7 +1066,9 @@ function runActorConnStateTests(driverTestConfig) {
           _vitest.expect.call(void 0, success).toBe(true);
           _vitest.expect.call(void 0, receivedMessages.length).toBe(1);
           _vitest.expect.call(void 0, receivedMessages[0].from).toBe(state1.id);
-          _vitest.expect.call(void 0, receivedMessages[0].message).toBe("Hello from conn1");
+          _vitest.expect.call(void 0, receivedMessages[0].message).toBe(
+            "Hello from conn1"
+          );
         });
         await conn1.dispose();
         await conn2.dispose();
@@ -1042,7 +1089,10 @@ function runActorScheduleTests(driverTestConfig) {
     () => {
       _vitest.describe.call(void 0, "Scheduled Alarms", () => {
         _vitest.test.call(void 0, "executes c.schedule.at() with specific timestamp", async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const scheduled = client.scheduled.getOrCreate();
           const timestamp = Date.now() + 250;
           await scheduled.scheduleTaskAt(timestamp);
@@ -1053,7 +1103,10 @@ function runActorScheduleTests(driverTestConfig) {
           _vitest.expect.call(void 0, scheduledCount).toBe(1);
         });
         _vitest.test.call(void 0, "executes c.schedule.after() with delay", async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const scheduled = client.scheduled.getOrCreate();
           await scheduled.scheduleTaskAfter(250);
           await waitFor(driverTestConfig, 500);
@@ -1063,7 +1116,10 @@ function runActorScheduleTests(driverTestConfig) {
           _vitest.expect.call(void 0, scheduledCount).toBe(1);
         });
         _vitest.test.call(void 0, "multiple scheduled tasks execute in order", async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const scheduled = client.scheduled.getOrCreate();
           await scheduled.clearHistory();
           await scheduled.scheduleTaskAfterWithId("first", 250);
@@ -1089,7 +1145,7 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 1e3;
-var sleep = _chunk2S7HJMMYcjs.actor.call(void 0, {
+var sleep = _chunkM5BHNJHBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1102,7 +1158,10 @@ var sleep = _chunk2S7HJMMYcjs.actor.call(void 0, {
       c.sleep();
     },
     getCounts: (c) => {
-      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
     },
     setAlarm: async (c, duration) => {
       await c.schedule.after(duration, "onAlarm");
@@ -1115,7 +1174,7 @@ var sleep = _chunk2S7HJMMYcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunk2S7HJMMYcjs.actor.call(void 0, {
+var sleepWithLongRpc = _chunkM5BHNJHBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -1126,11 +1185,14 @@ var sleepWithLongRpc = _chunk2S7HJMMYcjs.actor.call(void 0, {
   },
   actions: {
     getCounts: (c) => {
-      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
     },
     longRunningRpc: async (c) => {
       c.log.info("starting long running rpc");
-      c.vars.longRunningResolve = _chunkKUZWEM23cjs.promiseWithResolvers.call(void 0, );
+      c.vars.longRunningResolve = _chunkELDFBXDVcjs.promiseWithResolvers.call(void 0, );
       c.broadcast("waiting");
       await c.vars.longRunningResolve.promise;
       c.log.info("finished long running rpc");
@@ -1144,7 +1206,7 @@ var sleepWithLongRpc = _chunk2S7HJMMYcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunk2S7HJMMYcjs.actor.call(void 0, {
+var sleepWithRawHttp = _chunkM5BHNJHBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1156,7 +1218,9 @@ var sleepWithRawHttp = _chunk2S7HJMMYcjs.actor.call(void 0, {
     c.state.requestCount += 1;
     const url = new URL(request.url);
     if (url.pathname === "/long-request") {
-      const duration = parseInt(url.searchParams.get("duration") || "1000");
+      const duration = parseInt(
+        url.searchParams.get("duration") || "1000"
+      );
       c.log.info({ msg: "starting long fetch request", duration });
       await new Promise((resolve) => setTimeout(resolve, duration));
       c.log.info("finished long fetch request");
@@ -1179,7 +1243,7 @@ var sleepWithRawHttp = _chunk2S7HJMMYcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunk2S7HJMMYcjs.actor.call(void 0, {
+var sleepWithRawWebSocket = _chunkM5BHNJHBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1242,7 +1306,7 @@ var sleepWithRawWebSocket = _chunk2S7HJMMYcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunk2S7HJMMYcjs.actor.call(void 0, {
+var sleepWithNoSleepOption = _chunkM5BHNJHBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1252,7 +1316,10 @@ var sleepWithNoSleepOption = _chunk2S7HJMMYcjs.actor.call(void 0, {
   },
   actions: {
     getCounts: (c) => {
-      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount
+      };
     }
   },
   options: {
@@ -1675,7 +1742,9 @@ function runActorHandleTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "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"]);
+        const handle = client.counter.getOrCreate([
+          "test-get-for-id-handle"
+        ]);
         await handle.increment(3);
         const actorId = await handle.resolve();
         const idHandle = client.counter.getForId(actorId);
@@ -1699,7 +1768,9 @@ function runActorHandleTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "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 handle = await client.counter.create([
+          "test-create-handle"
+        ]);
         const count = await handle.increment(9);
         _vitest.expect.call(void 0, count).toBe(9);
         const retrievedCount = await handle.getCount();
@@ -1722,7 +1793,9 @@ function runActorHandleTests(driverTestConfig) {
         const missingId = `nonexistent-${crypto.randomUUID()}`;
         try {
           await client.counter.get([missingId]).resolve();
-          _vitest.expect.fail("did not error for get().resolve() on missing actor");
+          _vitest.expect.fail(
+            "did not error for get().resolve() on missing actor"
+          );
         } catch (err) {
           _vitest.expect.call(void 0, err.group).toBe("actor");
           _vitest.expect.call(void 0, err.code).toBe("not_found");
@@ -1732,7 +1805,9 @@ function runActorHandleTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Action Functionality", () => {
       _vitest.test.call(void 0, "should call actions directly on the handle", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.counter.getOrCreate(["test-action-handle"]);
+        const handle = client.counter.getOrCreate([
+          "test-action-handle"
+        ]);
         const count1 = await handle.increment(3);
         _vitest.expect.call(void 0, count1).toBe(3);
         const count2 = await handle.increment(5);
@@ -1742,7 +1817,9 @@ function runActorHandleTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle independent handles to the same actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle1 = client.counter.getOrCreate(["test-multiple-handles"]);
+        const handle1 = client.counter.getOrCreate([
+          "test-multiple-handles"
+        ]);
         const handle2 = client.counter.get(["test-multiple-handles"]);
         await handle1.increment(3);
         const count = await handle2.getCount();
@@ -1801,16 +1878,18 @@ function runActorHandleTests(driverTestConfig) {
         _vitest.expect.call(void 0, 
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        _vitest.expect.call(void 0, eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
-          1
-        );
+        _vitest.expect.call(void 0, 
+          eventsAfterAction.filter((e) => e === "onConnect").length
+        ).toBe(1);
         _vitest.expect.call(void 0, 
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
         _vitest.expect.call(void 0, 
-          eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length
+          eventsAfterSecondAction.filter(
+            (e) => e === "onBeforeConnect"
+          ).length
         ).toBe(2);
         _vitest.expect.call(void 0, 
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
@@ -1836,9 +1915,13 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
         _vitest.expect.call(void 0, events.filter((e) => e === "onStart").length).toBe(1);
-        _vitest.expect.call(void 0, events.filter((e) => e === "onBeforeConnect").length).toBe(2);
+        _vitest.expect.call(void 0, 
+          events.filter((e) => e === "onBeforeConnect").length
+        ).toBe(2);
         _vitest.expect.call(void 0, events.filter((e) => e === "onConnect").length).toBe(2);
-        _vitest.expect.call(void 0, events.filter((e) => e === "onDisconnect").length).toBe(2);
+        _vitest.expect.call(void 0, events.filter((e) => e === "onDisconnect").length).toBe(
+          2
+        );
       });
     });
   });
@@ -1851,23 +1934,25 @@ function runActorInlineClientTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Stateless Client Calls", () => {
       _vitest.test.call(void 0, "should make stateless calls to other actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const inlineClientHandle = client.inlineClientActor.getOrCreate([
-          "inline-client-test"
-        ]);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate(
+          ["inline-client-test"]
+        );
         const result = await inlineClientHandle.callCounterIncrement(5);
         _vitest.expect.call(void 0, result).toBe(5);
         const counterState = await inlineClientHandle.getCounterState();
         _vitest.expect.call(void 0, counterState).toBe(5);
         const messages = await inlineClientHandle.getMessages();
         _vitest.expect.call(void 0, messages).toHaveLength(2);
-        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(5), result: 5");
+        _vitest.expect.call(void 0, messages[0]).toContain(
+          "Called counter.increment(5), result: 5"
+        );
         _vitest.expect.call(void 0, messages[1]).toContain("Got counter state: 5");
       });
       _vitest.test.call(void 0, "should handle multiple stateless calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const inlineClientHandle = client.inlineClientActor.getOrCreate([
-          "inline-client-multi"
-        ]);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate(
+          ["inline-client-multi"]
+        );
         await inlineClientHandle.clearMessages();
         const result1 = await inlineClientHandle.callCounterIncrement(3);
         const result2 = await inlineClientHandle.callCounterIncrement(7);
@@ -1877,7 +1962,9 @@ function runActorInlineClientTests(driverTestConfig) {
         _vitest.expect.call(void 0, finalState).toBe(10);
         const messages = await inlineClientHandle.getMessages();
         _vitest.expect.call(void 0, messages).toHaveLength(3);
-        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(3), result: 3");
+        _vitest.expect.call(void 0, messages[0]).toContain(
+          "Called counter.increment(3), result: 3"
+        );
         _vitest.expect.call(void 0, messages[1]).toContain(
           "Called counter.increment(7), result: 10"
         );
@@ -1887,9 +1974,9 @@ function runActorInlineClientTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Stateful Client Calls", () => {
       _vitest.test.call(void 0, "should connect to other actors and receive events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const inlineClientHandle = client.inlineClientActor.getOrCreate([
-          "inline-client-stateful"
-        ]);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate(
+          ["inline-client-stateful"]
+        );
         await inlineClientHandle.clearMessages();
         const result = await inlineClientHandle.connectToCounterAndIncrement(4);
         _vitest.expect.call(void 0, result.result1).toBe(4);
@@ -1905,9 +1992,9 @@ function runActorInlineClientTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle stateful connection independently", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const inlineClientHandle = client.inlineClientActor.getOrCreate([
-          "inline-client-independent"
-        ]);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate(
+          ["inline-client-independent"]
+        );
         await inlineClientHandle.clearMessages();
         const result = await inlineClientHandle.connectToCounterAndIncrement(2);
         _vitest.expect.call(void 0, result.result1).toBe(2);
@@ -1923,9 +2010,9 @@ function runActorInlineClientTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Mixed Client Usage", () => {
       _vitest.test.call(void 0, "should handle both stateless and stateful calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const inlineClientHandle = client.inlineClientActor.getOrCreate([
-          "inline-client-mixed"
-        ]);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate(
+          ["inline-client-mixed"]
+        );
         await inlineClientHandle.clearMessages();
         await inlineClientHandle.callCounterIncrement(1);
         const statelessResult = await inlineClientHandle.getCounterState();
@@ -1935,7 +2022,9 @@ function runActorInlineClientTests(driverTestConfig) {
         _vitest.expect.call(void 0, statefulResult.result2).toBe(9);
         const messages = await inlineClientHandle.getMessages();
         _vitest.expect.call(void 0, messages).toHaveLength(3);
-        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(1), result: 1");
+        _vitest.expect.call(void 0, messages[0]).toContain(
+          "Called counter.increment(1), result: 1"
+        );
         _vitest.expect.call(void 0, messages[1]).toContain("Got counter state: 1");
         _vitest.expect.call(void 0, messages[2]).toContain(
           "Connected to counter, incremented by 3 and 6"
@@ -1952,25 +2041,34 @@ function runActorInspectorTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Manager Inspector", () => {
       _vitest.test.call(void 0, "should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
         _vitest.expect.call(void 0, data).toEqual({ message: "pong" });
       });
       _vitest.test.call(void 0, "should get actors with pagination", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         await client.counter.create(["test-actor-1"]);
         await client.counter.create(["test-actor-2"]);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "1" }
         });
@@ -1984,16 +2082,22 @@ function runActorInspectorTests(driverTestConfig) {
         _vitest.expect.call(void 0, data.length).toBe(1);
       });
       _vitest.test.call(void 0, "should get all actors with pagination", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const actorKey1 = ["test-cursor-1"];
         const actorKey2 = ["test-cursor-2"];
         await client.counter.create(actorKey1);
         await client.counter.create(actorKey2);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "5" }
         });
@@ -2014,11 +2118,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "0" }
         });
@@ -2026,11 +2133,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$post({
           json: {
             name: "default",
@@ -2050,11 +2160,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.builds.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2065,14 +2178,20 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       _vitest.test.call(void 0, "should get actor by id", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-get-by-id"]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actor[":id"].$get({
           param: { id: actorId }
         });
@@ -2082,11 +2201,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actor[":id"].$get({
           param: { id: "non-existent-id" }
         });
@@ -2095,14 +2217,20 @@ function runActorInspectorTests(driverTestConfig) {
         _vitest.expect.call(void 0, data).toEqual({ error: "Actor not found" });
       });
       _vitest.test.call(void 0, "should get bootstrap data", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = _chunkZNWE3XBTcjs.createManagerInspectorClient.call(void 0, 
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.bootstrap.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2120,47 +2248,62 @@ function runActorInspectorTests(driverTestConfig) {
       _vitest.test.call(void 0, "should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         _vitest.expect.call(void 0, response.ok).toBe(false);
       });
       _vitest.test.call(void 0, "should respond to ping", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-ping"]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
         _vitest.expect.call(void 0, data).toEqual({ message: "pong" });
       });
       _vitest.test.call(void 0, "should get actor state", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-state"]);
         const actorId = await handle.resolve();
         await handle.increment(5);
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.state.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2172,17 +2315,25 @@ function runActorInspectorTests(driverTestConfig) {
         });
       });
       _vitest.test.call(void 0, "should update actor state with replace", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
-        const handle = await client.counter.create(["test-state-replace"]);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const handle = await client.counter.create([
+          "test-state-replace"
+        ]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.state.$patch({
           json: {
             replace: { count: 10 }
@@ -2196,18 +2347,26 @@ function runActorInspectorTests(driverTestConfig) {
         });
       });
       _vitest.test.call(void 0, "should update actor state with patch", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
-        const handle = await client.counter.create(["test-state-patch"]);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const handle = await client.counter.create([
+          "test-state-patch"
+        ]);
         const actorId = await handle.resolve();
         await handle.increment(3);
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.state.$patch({
           json: {
             patch: [
@@ -2229,19 +2388,27 @@ function runActorInspectorTests(driverTestConfig) {
         });
       });
       _vitest.test.call(void 0, "should get actor connections", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
-        const handle = await client.counter.create(["test-connections"]);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const handle = await client.counter.create([
+          "test-connections"
+        ]);
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.connections.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2254,19 +2421,25 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       _vitest.test.call(void 0, "should get actor events", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-events"]);
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.events.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2280,19 +2453,27 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       _vitest.test.call(void 0, "should clear actor events", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
-        const handle = await client.counter.create(["test-events-clear"]);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const handle = await client.counter.create([
+          "test-events-clear"
+        ]);
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         {
           const response2 = await http.events.$get();
           _vitest.expect.call(void 0, response2.status).toBe(200);
@@ -2310,17 +2491,23 @@ function runActorInspectorTests(driverTestConfig) {
         _vitest.expect.call(void 0, response.status).toBe(200);
       });
       _vitest.test.call(void 0, "should get actor rpcs", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-rpcs"]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.rpcs.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2331,17 +2518,23 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       _vitest.test.skip("should get actor database info", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-db"]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.db.$get();
         _vitest.expect.call(void 0, response.status).toBe(200);
         const data = await response.json();
@@ -2355,17 +2548,23 @@ function runActorInspectorTests(driverTestConfig) {
         }
       });
       _vitest.test.skip("should execute database query when database is enabled", async (c) => {
-        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const { client, endpoint } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
         const handle = await client.counter.create(["test-db-query"]);
         const actorId = await handle.resolve();
-        const http = _chunkDUOTOMP7cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [_chunkPV22ZBDEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = _chunkZNWE3XBTcjs.createActorInspectorClient.call(void 0, 
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [_chunkJKOUXDK6cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const dbInfoResponse = await http.db.$get();
         const dbInfo = await dbInfoResponse.json();
         if (dbInfo.enabled) {
@@ -2529,7 +2728,10 @@ function runActorOnStateChangeTests(driverTestConfig) {
 function runActorReconnectTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor Reconnection Tests", () => {
     _vitest.test.call(void 0, "should reconnect and preserve connection state after non-clean disconnect", async (c) => {
-      const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+      const { client, endpoint } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
       const handle = client.counterConn.getOrCreate(["test-reconnect"]);
       const connection = handle.connect();
       await connection.increment(5);
@@ -2556,7 +2758,9 @@ function runActorReconnectTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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 handle = client.counterConn.getOrCreate([
+        "test-clean-disconnect"
+      ]);
       const connection = handle.connect();
       await connection.increment(10);
       const connCount1 = await connection.getConnectionCount();
@@ -2564,7 +2768,9 @@ function runActorReconnectTests(driverTestConfig) {
       await connection.dispose();
       await _vitest.vi.waitFor(
         async () => {
-          const handle2 = client.counterConn.get(["test-clean-disconnect"]);
+          const handle2 = client.counterConn.get([
+            "test-clean-disconnect"
+          ]);
           const connCount = await handle2.getConnectionCount();
           _vitest.expect.call(void 0, connCount).toBe(1);
         },
@@ -2578,7 +2784,10 @@ function runActorReconnectTests(driverTestConfig) {
       await connection2.dispose();
     });
     _vitest.test.call(void 0, "should handle multiple non-clean disconnects and reconnects", async (c) => {
-      const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+      const { client, endpoint } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
       const handle = client.counterConn.getOrCreate([
         "test-multiple-reconnect"
       ]);
@@ -2638,8 +2847,12 @@ function runActorVarsTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Deep cloning of static vars", () => {
       _vitest.test.call(void 0, "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 instance1 = client.nestedVarActor.getOrCreate([
+          "instance1"
+        ]);
+        const instance2 = client.nestedVarActor.getOrCreate([
+          "instance2"
+        ]);
         const modifiedVars = await instance1.modifyNested();
         _vitest.expect.call(void 0, modifiedVars.nested.value).toBe("modified");
         _vitest.expect.call(void 0, modifiedVars.nested.array).toContain(4);
@@ -2693,7 +2906,10 @@ function runManagerDriverTests(driverTestConfig) {
         const counterAAgain = client.counter.getOrCreate();
         const count = await counterAAgain.increment(0);
         _vitest.expect.call(void 0, count).toBe(5);
-        const counterB = client.counter.getOrCreate(["counter-b", "testing"]);
+        const counterB = client.counter.getOrCreate([
+          "counter-b",
+          "testing"
+        ]);
         await counterB.increment(10);
         const countB = await counterB.increment(0);
         _vitest.expect.call(void 0, countB).toBe(10);
@@ -2818,7 +3034,9 @@ function runManagerDriverTests(driverTestConfig) {
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
         _vitest.expect.call(void 0, subsetMatchCount).toBe(0);
-        const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
+        const singleKeyCounter = client.counter.getOrCreate([
+          "counter-match"
+        ]);
         const singleKeyCount = await singleKeyCounter.increment(0);
         _vitest.expect.call(void 0, singleKeyCount).toBe(0);
       });
@@ -2826,7 +3044,9 @@ function runManagerDriverTests(driverTestConfig) {
         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 arrayKeyCounter = client.counter.getOrCreate([
+          "string-key-test"
+        ]);
         const count = await arrayKeyCounter.increment(0);
         _vitest.expect.call(void 0, count).toBe(7);
       });
@@ -2954,14 +3174,18 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should return 404 when no onFetch handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpNoHandlerActor.getOrCreate(["no-handler"]);
+      const actor2 = client.rawHttpNoHandlerActor.getOrCreate([
+        "no-handler"
+      ]);
       const response = await actor2.fetch("api/anything");
       _vitest.expect.call(void 0, response.ok).toBe(false);
       _vitest.expect.call(void 0, response.status).toBe(404);
     });
     _vitest.test.call(void 0, "should return 500 error when onFetch returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpVoidReturnActor.getOrCreate(["void-return"]);
+      const actor2 = client.rawHttpVoidReturnActor.getOrCreate([
+        "void-return"
+      ]);
       const response = await actor2.fetch("api/anything");
       _vitest.expect.call(void 0, response.ok).toBe(false);
       _vitest.expect.call(void 0, response.status).toBe(500);
@@ -3087,7 +3311,10 @@ function runRawHttpTests(driverTestConfig) {
       const newRequest = new Request(url, {
         method: "GET"
       });
-      const response = await actor2.fetch(truncatedPath, newRequest);
+      const response = await actor2.fetch(
+        truncatedPath,
+        newRequest
+      );
       _vitest.expect.call(void 0, response.ok).toBe(true);
       const users = await response.json();
       _vitest.expect.call(void 0, users).toEqual([
@@ -3150,7 +3377,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw http request properties", () => {
     _vitest.test.call(void 0, "should pass all Request properties correctly to onFetch", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/path?foo=bar&baz=qux", {
         method: "POST",
         headers: {
@@ -3177,7 +3406,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle GET requests with no body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/get", {
         method: "GET"
       });
@@ -3188,7 +3419,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const formData = new URLSearchParams();
       formData.append("field1", "value1");
       formData.append("field2", "value2");
@@ -3219,7 +3452,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should preserve all header casing and values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/headers", {
         headers: {
           Accept: "application/json",
@@ -3239,7 +3474,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle empty and special URL paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const rootResponse = await actor2.fetch("");
       _vitest.expect.call(void 0, rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
@@ -3249,7 +3486,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       );
       _vitest.expect.call(void 0, specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      _vitest.expect.call(void 0, specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
+      _vitest.expect.call(void 0, specialData.pathname).toMatch(
+        /path.*with.*spaces.*and.*slashes/
+      );
       const fragmentResponse = await actor2.fetch("test/path#fragment");
       _vitest.expect.call(void 0, fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
@@ -3258,7 +3497,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const methods = [
         "GET",
         "POST",
@@ -3269,11 +3510,14 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         "OPTIONS"
       ];
       for (const method of methods) {
-        const response = await actor2.fetch(`test/${method.toLowerCase()}`, {
-          method,
-          // Only include body for methods that support it
-          body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
-        });
+        const response = await actor2.fetch(
+          `test/${method.toLowerCase()}`,
+          {
+            method,
+            // Only include body for methods that support it
+            body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
+          }
+        );
         if (method === "HEAD") {
           _vitest.expect.call(void 0, response.status).toBe(200);
           const text = await response.text();
@@ -3291,7 +3535,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle complex query parameters", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
@@ -3303,7 +3549,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const boundary = "----RivetKitBoundary";
       const body = [
         `------${boundary}`,
@@ -3325,13 +3573,17 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       });
       _vitest.expect.call(void 0, response.ok).toBe(true);
       const data = await response.json();
-      _vitest.expect.call(void 0, data.headers["content-type"]).toContain("multipart/form-data");
+      _vitest.expect.call(void 0, data.headers["content-type"]).toContain(
+        "multipart/form-data"
+      );
       _vitest.expect.call(void 0, data.bodyText).toContain("field1");
       _vitest.expect.call(void 0, data.bodyText).toContain("value1");
     });
     _vitest.test.call(void 0, "should handle very long URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const longValue = "x".repeat(1e3);
       const response = await actor2.fetch(`test/long?param=${longValue}`);
       _vitest.expect.call(void 0, response.ok).toBe(true);
@@ -3341,7 +3593,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const largeArray = new Array(1e4).fill({
         id: 1,
         name: "Test",
@@ -3360,7 +3614,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle missing content-type header", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/no-content-type", {
         method: "POST",
         body: "plain text without content-type"
@@ -3371,7 +3627,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle empty request body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/empty", {
         method: "POST",
         headers: {
@@ -3386,7 +3644,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       try {
         const response = await actor2.fetch("test/custom", {
           method: "CUSTOM"
@@ -3400,7 +3660,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle cookies in headers", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const response = await actor2.fetch("test/cookies", {
         headers: {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
@@ -3414,7 +3676,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle URL encoding properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      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"
       );
@@ -3426,7 +3690,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+        "test"
+      ]);
       const requests = [
         actor2.fetch("test/concurrent?id=1", {
           method: "POST",
@@ -3500,7 +3766,9 @@ function runRawWebSocketTests(driverTestConfig) {
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
-          ws.addEventListener("open", () => resolve(), { once: true });
+          ws.addEventListener("open", () => resolve(), {
+            once: true
+          });
           ws.addEventListener("close", reject);
         });
       }
@@ -3529,7 +3797,9 @@ function runRawWebSocketTests(driverTestConfig) {
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
-          ws.addEventListener("open", () => resolve(), { once: true });
+          ws.addEventListener("open", () => resolve(), {
+            once: true
+          });
           ws.addEventListener("close", reject);
         });
       }
@@ -3556,14 +3826,18 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.websocket();
       const ws1MessagePromise = new Promise((resolve, reject) => {
-        ws1.addEventListener("message", () => resolve(), { once: true });
+        ws1.addEventListener("message", () => resolve(), {
+          once: true
+        });
         ws1.addEventListener("close", reject);
       });
       await ws1MessagePromise;
       const actor2 = client.rawWebSocketActor.get(["stats"]);
       const ws2 = await actor2.websocket();
       const ws2MessagePromise = new Promise((resolve, reject) => {
-        ws2.addEventListener("message", () => resolve(), { once: true });
+        ws2.addEventListener("message", () => resolve(), {
+          once: true
+        });
         ws2.addEventListener("close", reject);
       });
       await Promise.all([ws1MessagePromise, ws2MessagePromise]);
@@ -3601,11 +3875,15 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketBinaryActor.getOrCreate(["binary"]);
+      const actor2 = client.rawWebSocketBinaryActor.getOrCreate([
+        "binary"
+      ]);
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
-          ws.addEventListener("open", () => resolve(), { once: true });
+          ws.addEventListener("open", () => resolve(), {
+            once: true
+          });
           ws.addEventListener("close", reject);
         });
       }
@@ -3636,7 +3914,9 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        _vitest.expect.call(void 0, largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+        _vitest.expect.call(void 0, largeReversed[i]).toBe(
+          largeData[largeData.length - 1 - i]
+        );
       }
       ws.close();
     });
@@ -3669,7 +3949,9 @@ function runRawWebSocketTests(driverTestConfig) {
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
-          ws.addEventListener("open", () => resolve(), { once: true });
+          ws.addEventListener("open", () => resolve(), {
+            once: true
+          });
           ws.addEventListener("close", reject);
         });
       }
@@ -3692,7 +3974,9 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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 actor2 = client.rawWebSocketActor.getOrCreate([
+        "open-close-test"
+      ]);
       const ws1 = await actor2.websocket();
       await new Promise((resolve, reject) => {
         ws1.addEventListener("open", () => resolve(), { once: true });
@@ -3758,8 +4042,12 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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");
+      const actor2 = client.rawWebSocketActor.getOrCreate([
+        "query-params"
+      ]);
+      const ws = await actor2.websocket(
+        "api/v1/stream?token=abc123&user=test"
+      );
       await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => resolve(), { once: true });
         ws.addEventListener("error", reject);
@@ -3789,20 +4077,27 @@ function runRequestAccessTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Request Access in Lifecycle Hooks", () => {
     _vitest.test.call(void 0, "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 }
-      });
+      const handle = client.requestAccessActor.getOrCreate(
+        ["test-request"],
+        {
+          params: { trackRequest: true }
+        }
+      );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
         _vitest.expect.call(void 0, requestInfo.onBeforeConnect.hasRequest).toBe(true);
         _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestUrl).toBeDefined();
         _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
+        _vitest.expect.call(void 0, 
+          requestInfo.onBeforeConnect.requestHeaders
+        ).toBeDefined();
         _vitest.expect.call(void 0, requestInfo.createConnState.hasRequest).toBe(true);
         _vitest.expect.call(void 0, requestInfo.createConnState.requestUrl).toBeDefined();
         _vitest.expect.call(void 0, requestInfo.createConnState.requestMethod).toBeDefined();
-        _vitest.expect.call(void 0, requestInfo.createConnState.requestHeaders).toBeDefined();
+        _vitest.expect.call(void 0, 
+          requestInfo.createConnState.requestHeaders
+        ).toBeDefined();
       } else {
       }
       await connection.dispose();
@@ -3833,9 +4128,12 @@ function runRequestAccessTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.requestAccessActor.getOrCreate(["test-headers"], {
-        params: { trackRequest: true }
-      });
+      const handle = client.requestAccessActor.getOrCreate(
+        ["test-headers"],
+        {
+          params: { trackRequest: true }
+        }
+      );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
@@ -3884,9 +4182,18 @@ function runDriverTests(driverTestConfigPartial) {
                 ...driverTestConfig,
                 transport
               });
-              runActorConnStateTests({ ...driverTestConfig, transport });
-              runActorReconnectTests({ ...driverTestConfig, transport });
-              runRequestAccessTests({ ...driverTestConfig, transport });
+              runActorConnStateTests({
+                ...driverTestConfig,
+                transport
+              });
+              runActorReconnectTests({
+                ...driverTestConfig,
+                transport
+              });
+              runRequestAccessTests({
+                ...driverTestConfig,
+                transport
+              });
               runActorDriverTestsWithTransport({
                 ...driverTestConfig,
                 transport
@@ -3933,7 +4240,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     };
   } else {
     let upgradeWebSocket;
-    const config = _chunkFYP3TZXDcjs.RunnerConfigSchema.parse({
+    const config = _chunkFDJ3AVNBcjs.RunnerConfigSchema.parse({
       driver,
       getUpgradeWebSocket: () => upgradeWebSocket,
       inspector: {
@@ -3942,12 +4249,12 @@ async function createTestRuntime(registryPath, driverFactory) {
       }
     });
     const managerDriver = driver.manager(registry.config, config);
-    const client = _chunkJZD6FEOEcjs.createClientWithDriver.call(void 0, 
+    const client = _chunkLMJHBF26cjs.createClientWithDriver.call(void 0, 
       managerDriver,
-      _chunkFYP3TZXDcjs.ClientConfigSchema.parse({})
+      _chunkFDJ3AVNBcjs.ClientConfigSchema.parse({})
     );
-    _chunkDUOTOMP7cjs.configureInspectorAccessToken.call(void 0, config, managerDriver);
-    const { router } = _chunk2S7HJMMYcjs.createManagerRouter.call(void 0, 
+    _chunkZNWE3XBTcjs.configureInspectorAccessToken.call(void 0, config, managerDriver);
+    const { router } = _chunkM5BHNJHBcjs.createManagerRouter.call(void 0, 
       registry.config,
       config,
       managerDriver,
@@ -3956,7 +4263,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-    const port = await _chunk2I6L3VROcjs.getPort.call(void 0, );
+    const port = await _chunkJTIBPF7Ncjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",
@@ -3970,7 +4277,9 @@ async function createTestRuntime(registryPath, driverFactory) {
     const serverEndpoint = `http://127.0.0.1:${port}`;
     logger().info({ msg: "test serer listening", port });
     const cleanup = async () => {
-      await new Promise((resolve) => server.close(() => resolve(void 0)));
+      await new Promise(
+        (resolve) => server.close(() => resolve(void 0))
+      );
       await (driverCleanup == null ? void 0 : driverCleanup());
     };
     return {