rivetkit 2.0.20 → 2.0.21

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

@@ -1,30 +1,30 @@
 import {
   getPort
-} from "../chunk-5F6X4AFU.js";
+} from "../chunk-3UIGKLZW.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-L3YPHXPE.js";
+} from "../chunk-2POQCWMA.js";
 import {
   configureInspectorAccessToken,
   createActorInspectorClient,
   createManagerInspectorClient
-} from "../chunk-RI4YHZZW.js";
+} from "../chunk-6G76WIWL.js";
 import {
   createClient
-} from "../chunk-M6LIJ6BK.js";
+} from "../chunk-4OINFQBR.js";
 import {
   ActorError,
   createClientWithDriver
-} from "../chunk-GQ5WTE64.js";
-import "../chunk-QRUGCDA5.js";
+} from "../chunk-Y2QONT7B.js";
+import "../chunk-DYA34FHW.js";
 import {
   importWebSocket
-} from "../chunk-MGHPBNWB.js";
+} from "../chunk-VLR3TDHT.js";
 import {
   ClientConfigSchema,
   RunnerConfigSchema
-} from "../chunk-7ACKZS3T.js";
+} from "../chunk-RZZDFDB6.js";
 import {
   HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
@@ -35,13 +35,13 @@ import {
   WS_PROTOCOL_TARGET,
   WS_PROTOCOL_TRANSPORT,
   assertUnreachable
-} from "../chunk-YFFCPYHY.js";
+} from "../chunk-D2LS4X6E.js";
 import {
   getLogger
-} from "../chunk-ER5OT3SQ.js";
+} from "../chunk-FUX6U6TL.js";
 import {
   promiseWithResolvers
-} from "../chunk-QMVCFQ37.js";
+} from "../chunk-HUGSRAGL.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
@@ -70,14 +70,22 @@ import * as cbor from "cbor-x";
 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,7 +117,11 @@ 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(HEADER_ACTOR_ID, actorId);
       const response = await fetch(
@@ -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(
@@ -650,7 +668,9 @@ function runActionFeaturesTests(driverTestConfig) {
           await instance.asyncWithError(true);
           expect.fail("did not error");
         } catch (error) {
-          expect(error.message).toBe("Intentional error");
+          expect(error.message).toBe(
+            "Intentional error"
+          );
         }
       });
       test("should handle promises returned from actions correctly", async (c) => {
@@ -697,7 +717,9 @@ function runActorConnTests(driverTestConfig) {
       });
       test2("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);
         expect2(count).toBe(7);
@@ -715,7 +737,9 @@ function runActorConnTests(driverTestConfig) {
     describe2("Event Communication", () => {
       test2("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 vi2.waitFor(async () => {
           await connection.setCount(5);
           expect2(receivedEvents).toEqual([5]);
@@ -789,12 +816,18 @@ function runActorConnTests(driverTestConfig) {
     describe2("Connection Parameters", () => {
       test2("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();
-        expect2(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
+        expect2(events).toEqual([
+          "onStart",
+          "onBeforeConnect",
+          "onConnect"
+        ]);
         await connection.dispose();
         await vi2.waitFor(
           async () => {
@@ -829,7 +866,12 @@ function runActorConnTests(driverTestConfig) {
             const finalEvents = await handle.getEvents();
             expect2(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 vi3.waitFor(async () => {
@@ -1021,7 +1066,9 @@ function runActorConnStateTests(driverTestConfig) {
           expect3(success).toBe(true);
           expect3(receivedMessages.length).toBe(1);
           expect3(receivedMessages[0].from).toBe(state1.id);
-          expect3(receivedMessages[0].message).toBe("Hello from conn1");
+          expect3(receivedMessages[0].message).toBe(
+            "Hello from conn1"
+          );
         });
         await conn1.dispose();
         await conn2.dispose();
@@ -1042,7 +1089,10 @@ function runActorScheduleTests(driverTestConfig) {
     () => {
       describe4("Scheduled Alarms", () => {
         test4("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) {
           expect4(scheduledCount).toBe(1);
         });
         test4("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) {
           expect4(scheduledCount).toBe(1);
         });
         test4("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);
@@ -1102,7 +1158,10 @@ var sleep = actor({
       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");
@@ -1126,7 +1185,10 @@ var sleepWithLongRpc = actor({
   },
   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");
@@ -1156,7 +1218,9 @@ var sleepWithRawHttp = actor({
     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");
@@ -1252,7 +1316,10 @@ var sleepWithNoSleepOption = actor({
   },
   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) {
       });
       test8("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) {
       });
       test8("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);
         expect8(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();
-          expect8.fail("did not error for get().resolve() on missing actor");
+          expect8.fail(
+            "did not error for get().resolve() on missing actor"
+          );
         } catch (err) {
           expect8(err.group).toBe("actor");
           expect8(err.code).toBe("not_found");
@@ -1732,7 +1805,9 @@ function runActorHandleTests(driverTestConfig) {
     describe9("Action Functionality", () => {
       test8("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);
         expect8(count1).toBe(3);
         const count2 = await handle.increment(5);
@@ -1742,7 +1817,9 @@ function runActorHandleTests(driverTestConfig) {
       });
       test8("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) {
         expect8(
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        expect8(eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
-          1
-        );
+        expect8(
+          eventsAfterAction.filter((e) => e === "onConnect").length
+        ).toBe(1);
         expect8(
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
         expect8(
-          eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length
+          eventsAfterSecondAction.filter(
+            (e) => e === "onBeforeConnect"
+          ).length
         ).toBe(2);
         expect8(
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
@@ -1836,9 +1915,13 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
         expect8(events.filter((e) => e === "onStart").length).toBe(1);
-        expect8(events.filter((e) => e === "onBeforeConnect").length).toBe(2);
+        expect8(
+          events.filter((e) => e === "onBeforeConnect").length
+        ).toBe(2);
         expect8(events.filter((e) => e === "onConnect").length).toBe(2);
-        expect8(events.filter((e) => e === "onDisconnect").length).toBe(2);
+        expect8(events.filter((e) => e === "onDisconnect").length).toBe(
+          2
+        );
       });
     });
   });
@@ -1851,23 +1934,25 @@ function runActorInlineClientTests(driverTestConfig) {
     describe10("Stateless Client Calls", () => {
       test9("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);
         expect9(result).toBe(5);
         const counterState = await inlineClientHandle.getCounterState();
         expect9(counterState).toBe(5);
         const messages = await inlineClientHandle.getMessages();
         expect9(messages).toHaveLength(2);
-        expect9(messages[0]).toContain("Called counter.increment(5), result: 5");
+        expect9(messages[0]).toContain(
+          "Called counter.increment(5), result: 5"
+        );
         expect9(messages[1]).toContain("Got counter state: 5");
       });
       test9("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) {
         expect9(finalState).toBe(10);
         const messages = await inlineClientHandle.getMessages();
         expect9(messages).toHaveLength(3);
-        expect9(messages[0]).toContain("Called counter.increment(3), result: 3");
+        expect9(messages[0]).toContain(
+          "Called counter.increment(3), result: 3"
+        );
         expect9(messages[1]).toContain(
           "Called counter.increment(7), result: 10"
         );
@@ -1887,9 +1974,9 @@ function runActorInlineClientTests(driverTestConfig) {
     describe10("Stateful Client Calls", () => {
       test9("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);
         expect9(result.result1).toBe(4);
@@ -1905,9 +1992,9 @@ function runActorInlineClientTests(driverTestConfig) {
       });
       test9("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);
         expect9(result.result1).toBe(2);
@@ -1923,9 +2010,9 @@ function runActorInlineClientTests(driverTestConfig) {
     describe10("Mixed Client Usage", () => {
       test9("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) {
         expect9(statefulResult.result2).toBe(9);
         const messages = await inlineClientHandle.getMessages();
         expect9(messages).toHaveLength(3);
-        expect9(messages[0]).toContain("Called counter.increment(1), result: 1");
+        expect9(messages[0]).toContain(
+          "Called counter.increment(1), result: 1"
+        );
         expect9(messages[1]).toContain("Got counter state: 1");
         expect9(messages[2]).toContain(
           "Connected to counter, incremented by 3 and 6"
@@ -1952,25 +2041,34 @@ function runActorInspectorTests(driverTestConfig) {
     describe11("Manager Inspector", () => {
       test10("should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
         expect10(data).toEqual({ message: "pong" });
       });
       test10("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "1" }
         });
@@ -1984,16 +2082,22 @@ function runActorInspectorTests(driverTestConfig) {
         expect10(data.length).toBe(1);
       });
       test10("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "5" }
         });
@@ -2014,11 +2118,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       test10("should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$get({
           query: { limit: "0" }
         });
@@ -2026,11 +2133,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       test10("should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actors.$post({
           json: {
             name: "default",
@@ -2050,11 +2160,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       test10("should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.builds.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2065,14 +2178,20 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       test10("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.actor[":id"].$get({
           param: { id: actorId }
         });
@@ -2082,11 +2201,14 @@ function runActorInspectorTests(driverTestConfig) {
       });
       test10("should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${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) {
         expect10(data).toEqual({ error: "Actor not found" });
       });
       test10("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
-          headers: {
-            Authorization: `Bearer token`
+        const http = createManagerInspectorClient(
+          `${endpoint}/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`
+            }
           }
-        });
+        );
         const response = await http.bootstrap.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2120,47 +2248,62 @@ function runActorInspectorTests(driverTestConfig) {
       test10("should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
-        const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         expect10(response.ok).toBe(false);
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.ping.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
         expect10(data).toEqual({ message: "pong" });
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.state.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2172,17 +2315,25 @@ function runActorInspectorTests(driverTestConfig) {
         });
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [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) {
         });
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.state.$patch({
           json: {
             patch: [
@@ -2229,19 +2388,27 @@ function runActorInspectorTests(driverTestConfig) {
         });
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.connections.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2254,19 +2421,25 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.events.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2280,19 +2453,27 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         {
           const response2 = await http.events.$get();
           expect10(response2.status).toBe(200);
@@ -2310,17 +2491,23 @@ function runActorInspectorTests(driverTestConfig) {
         expect10(response.status).toBe(200);
       });
       test10("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.rpcs.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2331,17 +2518,23 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
       test10.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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [HEADER_ACTOR_QUERY]: JSON.stringify({
+                getForId: { name: "counter", actorId }
+              })
+            }
           }
-        });
+        );
         const response = await http.db.$get();
         expect10(response.status).toBe(200);
         const data = await response.json();
@@ -2355,17 +2548,23 @@ function runActorInspectorTests(driverTestConfig) {
         }
       });
       test10.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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
-          headers: {
-            Authorization: `Bearer token`,
-            [HEADER_ACTOR_QUERY]: JSON.stringify({
-              getForId: { name: "counter", actorId }
-            })
+        const http = createActorInspectorClient(
+          `${endpoint}/actors/inspect`,
+          {
+            headers: {
+              Authorization: `Bearer token`,
+              [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 @@ import { describe as describe14, expect as expect13, test as test13, vi as vi4 }
 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 { 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) {
     });
     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 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 vi4.waitFor(
         async () => {
-          const handle2 = client.counterConn.get(["test-clean-disconnect"]);
+          const handle2 = client.counterConn.get([
+            "test-clean-disconnect"
+          ]);
           const connCount = await handle2.getConnectionCount();
           expect13(connCount).toBe(1);
         },
@@ -2578,7 +2784,10 @@ function runActorReconnectTests(driverTestConfig) {
       await connection2.dispose();
     });
     test13("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) {
     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 instance1 = client.nestedVarActor.getOrCreate([
+          "instance1"
+        ]);
+        const instance2 = client.nestedVarActor.getOrCreate([
+          "instance2"
+        ]);
         const modifiedVars = await instance1.modifyNested();
         expect14(modifiedVars.nested.value).toBe("modified");
         expect14(modifiedVars.nested.array).toContain(4);
@@ -2693,7 +2906,10 @@ function runManagerDriverTests(driverTestConfig) {
         const counterAAgain = client.counter.getOrCreate();
         const count = await counterAAgain.increment(0);
         expect15(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);
         expect15(countB).toBe(10);
@@ -2818,7 +3034,9 @@ function runManagerDriverTests(driverTestConfig) {
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
         expect15(subsetMatchCount).toBe(0);
-        const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
+        const singleKeyCounter = client.counter.getOrCreate([
+          "counter-match"
+        ]);
         const singleKeyCount = await singleKeyCounter.increment(0);
         expect15(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);
         expect15(count).toBe(7);
       });
@@ -2954,14 +3174,18 @@ function runRawHttpTests(driverTestConfig) {
     });
     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 actor2 = client.rawHttpNoHandlerActor.getOrCreate([
+        "no-handler"
+      ]);
       const response = await actor2.fetch("api/anything");
       expect16(response.ok).toBe(false);
       expect16(response.status).toBe(404);
     });
     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 actor2 = client.rawHttpVoidReturnActor.getOrCreate([
+        "void-return"
+      ]);
       const response = await actor2.fetch("api/anything");
       expect16(response.ok).toBe(false);
       expect16(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
+      );
       expect16(response.ok).toBe(true);
       const users = await response.json();
       expect16(users).toEqual([
@@ -3150,7 +3377,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
   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 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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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("");
       expect17(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
@@ -3249,7 +3486,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       );
       expect17(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect17(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");
       expect17(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
@@ -3258,7 +3497,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     test17("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") {
           expect17(response.status).toBe(200);
           const text = await response.text();
@@ -3291,7 +3535,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     test17("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) {
     });
     test17("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) {
       });
       expect17(response.ok).toBe(true);
       const data = await response.json();
-      expect17(data.headers["content-type"]).toContain("multipart/form-data");
+      expect17(data.headers["content-type"]).toContain(
+        "multipart/form-data"
+      );
       expect17(data.bodyText).toContain("field1");
       expect17(data.bodyText).toContain("value1");
     });
     test17("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}`);
       expect17(response.ok).toBe(true);
@@ -3341,7 +3593,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test17("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) {
     });
     test18("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++) {
-        expect18(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+        expect18(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) {
     });
     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 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) {
     });
     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");
+      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) {
   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 }
-      });
+      const handle = client.requestAccessActor.getOrCreate(
+        ["test-request"],
+        {
+          params: { trackRequest: true }
+        }
+      );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
         expect19(requestInfo.onBeforeConnect.hasRequest).toBe(true);
         expect19(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
         expect19(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        expect19(requestInfo.onBeforeConnect.requestHeaders).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();
+        expect19(
+          requestInfo.createConnState.requestHeaders
+        ).toBeDefined();
       } else {
       }
       await connection.dispose();
@@ -3833,9 +4128,12 @@ function runRequestAccessTests(driverTestConfig) {
     });
     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 }
-      });
+      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
@@ -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 {