rivetkit 2.0.41 → 2.0.43-rc.1

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

@@ -1,21 +1,22 @@
 "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 _chunkQDVKDX7Gcjs = require('../chunk-QDVKDX7G.cjs');
 
 
-var _chunk4UHJ3ADWcjs = require('../chunk-4UHJ3ADW.cjs');
-require('../chunk-GTQKDCM4.cjs');
+var _chunkR33VIC3Wcjs = require('../chunk-R33VIC3W.cjs');
 
 
+var _chunkROVVTBUEcjs = require('../chunk-ROVVTBUE.cjs');
+require('../chunk-MQ3PTGWH.cjs');
+require('../chunk-ETNL2HZL.cjs');
 
 
 
-var _chunkWYZLRPQMcjs = require('../chunk-WYZLRPQM.cjs');
 
 
-var _chunkDSNSFYDLcjs = require('../chunk-DSNSFYDL.cjs');
+var _chunkYR6H6STIcjs = require('../chunk-YR6H6STI.cjs');
 
 
+var _chunk3HKN5HQ7cjs = require('../chunk-3HKN5HQ7.cjs');
 
 
 
@@ -24,17 +25,17 @@ var _chunkDSNSFYDLcjs = require('../chunk-DSNSFYDL.cjs');
 
 
 
-var _chunkB5UXC4QVcjs = require('../chunk-B5UXC4QV.cjs');
-require('../chunk-KDFWJKMJ.cjs');
 
 
+var _chunkBEMEUFS2cjs = require('../chunk-BEMEUFS2.cjs');
+require('../chunk-KDFWJKMJ.cjs');
 
 
-var _chunkS6F7EKC7cjs = require('../chunk-S6F7EKC7.cjs');
+var _chunkYZZF7DEScjs = require('../chunk-YZZF7DES.cjs');
 
 
 
-var _chunkSNAUKDDKcjs = require('../chunk-SNAUKDDK.cjs');
+var _chunk2XQS746Mcjs = require('../chunk-2XQS746M.cjs');
 require('../chunk-GBENOENJ.cjs');
 
 // src/driver-test-suite/mod.ts
@@ -43,11 +44,6 @@ var _nodews = require('@hono/node-ws');
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
 var _vitest = require('vitest');
 
-// src/driver-test-suite/log.ts
-function logger() {
-  return _chunkS6F7EKC7cjs.getLogger.call(void 0, "test-suite");
-}
-
 // src/driver-test-suite/tests/action-features.ts
 
 
@@ -84,20 +80,20 @@ function createTestInlineClientDriver(endpoint, encoding) {
       const oldUrl = new URL(actorRequest.url);
       const normalizedPath = oldUrl.pathname.startsWith("/") ? oldUrl.pathname.slice(1) : oldUrl.pathname;
       const pathWithQuery = normalizedPath + oldUrl.search;
-      logger().debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "sending raw http request via test inline driver",
         actorId,
         encoding,
         path: pathWithQuery
       });
       const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
-      logger().debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "rewriting http url",
         from: oldUrl,
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkB5UXC4QVcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkBEMEUFS2cjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -113,7 +109,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkWYZLRPQMcjs.ActorError)(
+              throw new (0, _chunkYR6H6STIcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -121,7 +117,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkWYZLRPQMcjs.ActorError)) {
+          if (!(e instanceof _chunkYR6H6STIcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -130,33 +126,33 @@ function createTestInlineClientDriver(endpoint, encoding) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkDSNSFYDLcjs.importWebSocket.call(void 0, );
+      const WebSocket2 = await _chunk3HKN5HQ7cjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      logger().debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "creating websocket connection via test inline driver",
         url: wsUrl.toString()
       });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       const protocols = [];
-      protocols.push(_chunkB5UXC4QVcjs.WS_PROTOCOL_STANDARD);
-      protocols.push(`${_chunkB5UXC4QVcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(_chunkBEMEUFS2cjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunkBEMEUFS2cjs.WS_PROTOCOL_TARGET}actor`);
       protocols.push(
-        `${_chunkB5UXC4QVcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+        `${_chunkBEMEUFS2cjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
       );
-      protocols.push(`${_chunkB5UXC4QVcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkBEMEUFS2cjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunkB5UXC4QVcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunkBEMEUFS2cjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunkB5UXC4QVcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunkBEMEUFS2cjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
-      logger().debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "connecting to websocket",
         url: finalWsUrl,
         protocols
@@ -176,7 +172,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
         encoding2,
         params
       );
-      return upgradeWebSocket(() => wsHandler)(c, _chunkS6F7EKC7cjs.noopNext.call(void 0, ));
+      return upgradeWebSocket(() => wsHandler)(c, _chunkYZZF7DEScjs.noopNext.call(void 0, ));
     },
     async buildGatewayUrl(actorId) {
       return `${endpoint}/gateway/${actorId}`;
@@ -193,7 +189,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
   };
 }
 async function makeInlineRequest(endpoint, encoding, method, args) {
-  logger().debug({
+  _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
     msg: "sending inline request",
     encoding,
     method,
@@ -223,14 +219,14 @@ async function makeInlineRequest(endpoint, encoding, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkWYZLRPQMcjs.ActorError)(
+    throw new (0, _chunkYR6H6STIcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkB5UXC4QVcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkBEMEUFS2cjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -243,12 +239,12 @@ async function setupDriverTest(c, driverTestConfig) {
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   c.onTestFinished(() => {
-    logger().info("cleaning up test");
+    _chunkR33VIC3Wcjs.logger.call(void 0, ).info("cleaning up test");
     cleanup();
   });
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkWYZLRPQMcjs.createClient.call(void 0, {
+    client = _chunkYR6H6STIcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -261,12 +257,12 @@ async function setupDriverTest(c, driverTestConfig) {
   } else if (driverTestConfig.clientType === "inline") {
     const encoding = _nullishCoalesce(driverTestConfig.encoding, () => ( "bare"));
     const managerDriver = createTestInlineClientDriver(endpoint, encoding);
-    const runConfig = _chunkWYZLRPQMcjs.ClientConfigSchema.parse({
+    const runConfig = _chunkYR6H6STIcjs.ClientConfigSchema.parse({
       encoding
     });
-    client = _chunkWYZLRPQMcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkYR6H6STIcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkB5UXC4QVcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkBEMEUFS2cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -787,76 +783,6 @@ function runActorConnTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-conn-hibernation.ts
 
-
-// fixtures/driver-test-suite/hibernation.ts
-var HIBERNATION_SLEEP_TIMEOUT = 500;
-var hibernationActor = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: {
-    sleepCount: 0,
-    wakeCount: 0
-  },
-  createConnState: (c) => {
-    return {
-      count: 0,
-      connectCount: 0,
-      disconnectCount: 0
-    };
-  },
-  onWake: (c) => {
-    c.state.wakeCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  onConnect: (c, conn) => {
-    conn.state.connectCount += 1;
-  },
-  onDisconnect: (c, conn) => {
-    conn.state.disconnectCount += 1;
-  },
-  actions: {
-    // Basic RPC that returns a simple value
-    ping: (c) => {
-      return "pong";
-    },
-    // Increment the connection's count
-    connIncrement: (c) => {
-      c.conn.state.count += 1;
-      return c.conn.state.count;
-    },
-    // Get the connection's count
-    getConnCount: (c) => {
-      return c.conn.state.count;
-    },
-    // Get the connection's lifecycle counts
-    getConnLifecycleCounts: (c) => {
-      return {
-        connectCount: c.conn.state.connectCount,
-        disconnectCount: c.conn.state.disconnectCount
-      };
-    },
-    // Get all connection IDs
-    getConnectionIds: (c) => {
-      return c.conns.entries().map((x) => x[0]).toArray();
-    },
-    // Get actor sleep/wake counts
-    getActorCounts: (c) => {
-      return {
-        sleepCount: c.state.sleepCount,
-        wakeCount: c.state.wakeCount
-      };
-    },
-    // Trigger sleep
-    triggerSleep: (c) => {
-      c.sleep();
-    }
-  },
-  options: {
-    sleepTimeout: HIBERNATION_SLEEP_TIMEOUT
-  }
-});
-
-// src/driver-test-suite/tests/actor-conn-hibernation.ts
 function runActorConnHibernationTests(driverTestConfig) {
   var _a;
   _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
@@ -870,7 +796,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
         _vitest.expect.call(void 0, ping2).toBe("pong");
@@ -892,7 +818,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
         _vitest.expect.call(void 0, count3).toBe(2);
@@ -914,7 +840,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await conn1.triggerSleep();
         await waitFor(
           driverTestConfig,
-          HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         await conn1.dispose();
         await waitFor(driverTestConfig, 250);
@@ -1120,6 +1046,44 @@ function runActorConnStateTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/conn-error-serialization.ts
+
+function runConnErrorSerializationTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Connection Error Serialization Tests", () => {
+    _vitest.test.call(void 0, "error thrown in createConnState preserves group and code through WebSocket serialization", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-error-serialization-${Date.now()}`;
+      const actor = client.connErrorSerializationActor.getOrCreate(
+        [actorKey],
+        { params: { shouldThrow: true } }
+      );
+      const conn = actor.connect();
+      let caughtError;
+      try {
+        await conn.getValue();
+      } catch (err) {
+        caughtError = err;
+      }
+      _vitest.expect.call(void 0, caughtError).toBeDefined();
+      _vitest.expect.call(void 0, caughtError.group).toBe("connection");
+      _vitest.expect.call(void 0, caughtError.code).toBe("custom_error");
+      await conn.dispose();
+    });
+    _vitest.test.call(void 0, "successful createConnState does not throw error", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-no-error-${Date.now()}`;
+      const actor = client.connErrorSerializationActor.getOrCreate(
+        [actorKey],
+        { params: { shouldThrow: false } }
+      );
+      const conn = actor.connect();
+      const value = await conn.getValue();
+      _vitest.expect.call(void 0, value).toBe(0);
+      await conn.dispose();
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-destroy.ts
 
 function runActorDestroyTests(driverTestConfig) {
@@ -1308,6 +1272,102 @@ function runActorDestroyTests(driverTestConfig) {
 // src/driver-test-suite/tests/actor-driver.ts
 
 
+// src/driver-test-suite/tests/actor-lifecycle.ts
+
+function runActorLifecycleTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Lifecycle Tests", () => {
+    _vitest.test.call(void 0, "actor stop during start waits for start to complete", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-stop-during-start-${Date.now()}`;
+      const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+      const pingPromise = actor.ping();
+      const actorId = await actor.resolve();
+      await actor.destroy();
+      const result = await pingPromise;
+      _vitest.expect.call(void 0, result).toBe("pong");
+      let destroyed = false;
+      try {
+        await client.startStopRaceActor.getForId(actorId).ping();
+      } catch (err) {
+        destroyed = true;
+        _vitest.expect.call(void 0, err.group).toBe("actor");
+        _vitest.expect.call(void 0, err.code).toBe("not_found");
+      }
+      _vitest.expect.call(void 0, destroyed).toBe(true);
+    });
+    _vitest.test.call(void 0, "actor stop before actor instantiation completes cleans up handler", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-stop-before-instantiation-${Date.now()}`;
+      const actors = Array.from(
+        { length: 5 },
+        (_, i) => client.startStopRaceActor.getOrCreate([
+          `${actorKey}-${i}`
+        ])
+      );
+      const ids = await Promise.all(actors.map((a) => a.resolve()));
+      await Promise.all(actors.map((a) => a.destroy()));
+      for (const id of ids) {
+        let destroyed = false;
+        try {
+          await client.startStopRaceActor.getForId(id).ping();
+        } catch (err) {
+          destroyed = true;
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
+        }
+        _vitest.expect.call(void 0, destroyed, `actor ${id} should be destroyed`).toBe(
+          true
+        );
+      }
+    });
+    _vitest.test.call(void 0, "onBeforeActorStart completes before stop proceeds", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-before-actor-start-${Date.now()}`;
+      const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+      const statePromise = actor.getState();
+      await actor.destroy();
+      const state = await statePromise;
+      _vitest.expect.call(void 0, state.initialized).toBe(true);
+      _vitest.expect.call(void 0, state.startCompleted).toBe(true);
+    });
+    _vitest.test.call(void 0, "multiple rapid create/destroy cycles handle race correctly", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      for (let i = 0; i < 10; i++) {
+        const actorKey = `test-rapid-cycle-${Date.now()}-${i}`;
+        const actor = client.startStopRaceActor.getOrCreate([
+          actorKey
+        ]);
+        const resolvePromise = actor.resolve();
+        const destroyPromise = actor.destroy();
+        await Promise.all([resolvePromise, destroyPromise]);
+      }
+      _vitest.expect.call(void 0, true).toBe(true);
+    });
+    _vitest.test.call(void 0, "actor stop called with no actor instance cleans up handler", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-cleanup-no-instance-${Date.now()}`;
+      const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+      const id = await actor.resolve();
+      await actor.destroy();
+      const newActor = client.startStopRaceActor.getOrCreate([
+        actorKey
+      ]);
+      const result = await newActor.ping();
+      _vitest.expect.call(void 0, result).toBe("pong");
+      await newActor.destroy();
+    });
+    _vitest.test.call(void 0, "onDestroy is called even when actor is destroyed during start", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = `test-ondestroy-during-start-${Date.now()}`;
+      const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+      const statePromise = actor.getState();
+      await actor.destroy();
+      const state = await statePromise;
+      _vitest.expect.call(void 0, state.destroyCalled).toBe(true);
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-schedule.ts
 
 function runActorScheduleTests(driverTestConfig) {
@@ -1370,193 +1430,6 @@ function runActorScheduleTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-sleep.ts
 
-
-// fixtures/driver-test-suite/sleep.ts
-var SLEEP_TIMEOUT = 1e3;
-var sleep = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: { startCount: 0, sleepCount: 0 },
-  onWake: (c) => {
-    c.state.startCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  actions: {
-    triggerSleep: (c) => {
-      c.sleep();
-    },
-    getCounts: (c) => {
-      return {
-        startCount: c.state.startCount,
-        sleepCount: c.state.sleepCount
-      };
-    },
-    setAlarm: async (c, duration) => {
-      await c.schedule.after(duration, "onAlarm");
-    },
-    onAlarm: (c) => {
-      c.log.info("alarm called");
-    }
-  },
-  options: {
-    sleepTimeout: SLEEP_TIMEOUT
-  }
-});
-var sleepWithLongRpc = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: { startCount: 0, sleepCount: 0 },
-  createVars: () => ({}),
-  onWake: (c) => {
-    c.state.startCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  actions: {
-    getCounts: (c) => {
-      return {
-        startCount: c.state.startCount,
-        sleepCount: c.state.sleepCount
-      };
-    },
-    longRunningRpc: async (c) => {
-      c.log.info("starting long running rpc");
-      c.vars.longRunningResolve = _chunkS6F7EKC7cjs.promiseWithResolvers.call(void 0, );
-      c.broadcast("waiting");
-      await c.vars.longRunningResolve.promise;
-      c.log.info("finished long running rpc");
-    },
-    finishLongRunningRpc: (c) => {
-      var _a;
-      return (_a = c.vars.longRunningResolve) == null ? void 0 : _a.resolve();
-    }
-  },
-  options: {
-    sleepTimeout: SLEEP_TIMEOUT
-  }
-});
-var sleepWithRawHttp = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: { startCount: 0, sleepCount: 0, requestCount: 0 },
-  onWake: (c) => {
-    c.state.startCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  onRequest: async (c, request) => {
-    c.state.requestCount += 1;
-    const url = new URL(request.url);
-    if (url.pathname === "/long-request") {
-      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");
-      return new Response(JSON.stringify({ completed: true }), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  },
-  actions: {
-    getCounts: (c) => {
-      return {
-        startCount: c.state.startCount,
-        sleepCount: c.state.sleepCount,
-        requestCount: c.state.requestCount
-      };
-    }
-  },
-  options: {
-    sleepTimeout: SLEEP_TIMEOUT
-  }
-});
-var sleepWithRawWebSocket = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
-  onWake: (c) => {
-    c.state.startCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  onWebSocket: (c, websocket) => {
-    c.state.connectionCount += 1;
-    c.log.info({
-      msg: "websocket connected",
-      connectionCount: c.state.connectionCount
-    });
-    websocket.send(
-      JSON.stringify({
-        type: "connected",
-        connectionCount: c.state.connectionCount
-      })
-    );
-    websocket.addEventListener("message", (event) => {
-      const data = event.data;
-      if (typeof data === "string") {
-        try {
-          const parsed = JSON.parse(data);
-          if (parsed.type === "getCounts") {
-            websocket.send(
-              JSON.stringify({
-                type: "counts",
-                startCount: c.state.startCount,
-                sleepCount: c.state.sleepCount,
-                connectionCount: c.state.connectionCount
-              })
-            );
-          } else if (parsed.type === "keepAlive") {
-            websocket.send(JSON.stringify({ type: "ack" }));
-          }
-        } catch (e2) {
-          websocket.send(data);
-        }
-      }
-    });
-    websocket.addEventListener("close", () => {
-      c.state.connectionCount -= 1;
-      c.log.info({
-        msg: "websocket disconnected",
-        connectionCount: c.state.connectionCount
-      });
-    });
-  },
-  actions: {
-    getCounts: (c) => {
-      return {
-        startCount: c.state.startCount,
-        sleepCount: c.state.sleepCount,
-        connectionCount: c.state.connectionCount
-      };
-    }
-  },
-  options: {
-    sleepTimeout: SLEEP_TIMEOUT
-  }
-});
-var sleepWithNoSleepOption = _chunk4UHJ3ADWcjs.actor.call(void 0, {
-  state: { startCount: 0, sleepCount: 0 },
-  onWake: (c) => {
-    c.state.startCount += 1;
-  },
-  onSleep: (c) => {
-    c.state.sleepCount += 1;
-  },
-  actions: {
-    getCounts: (c) => {
-      return {
-        startCount: c.state.startCount,
-        sleepCount: c.state.sleepCount
-      };
-    }
-  },
-  options: {
-    sleepTimeout: SLEEP_TIMEOUT,
-    noSleep: true
-  }
-});
-
-// src/driver-test-suite/tests/actor-sleep.ts
 function runActorSleepTests(driverTestConfig) {
   var _a;
   _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
@@ -1586,7 +1459,7 @@ function runActorSleepTests(driverTestConfig) {
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1602,7 +1475,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1618,7 +1491,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1634,19 +1507,19 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1661,8 +1534,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(SLEEP_TIMEOUT - 250);
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await sleepActor.setAlarm(_chunkR33VIC3Wcjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1677,8 +1550,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(SLEEP_TIMEOUT + 250);
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
+      await sleepActor.setAlarm(_chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1698,7 +1571,7 @@ function runActorSleepTests(driverTestConfig) {
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       await sleepActor.finishLongRunningRpc();
       await longRunningPromise;
       {
@@ -1707,7 +1580,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1739,7 +1612,7 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       ws.send(JSON.stringify({ type: "getCounts" }));
       const counts = await new Promise((resolve) => {
         ws.onmessage = (event) => {
@@ -1752,7 +1625,7 @@ function runActorSleepTests(driverTestConfig) {
       _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
       _vitest.expect.call(void 0, counts.startCount).toBe(1);
       ws.close();
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1770,7 +1643,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const fetchDuration = SLEEP_TIMEOUT + 250;
+      const fetchDuration = _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
         `long-request?duration=${fetchDuration}`
       );
@@ -1783,7 +1656,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
         _vitest.expect.call(void 0, requestCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1798,13 +1671,13 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1857,6 +1730,7 @@ function runActorDriverTests(driverTestConfig) {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
     runActorSleepTests(driverTestConfig);
+    runActorLifecycleTests(driverTestConfig);
   });
 }
 
@@ -1900,8 +1774,8 @@ function runActorErrorHandlingTests(driverTestConfig) {
           await handle.throwInternalError();
           _vitest.expect.call(void 0, true).toBe(false);
         } catch (error) {
-          _vitest.expect.call(void 0, error.code).toBe(_chunkSNAUKDDKcjs.INTERNAL_ERROR_CODE);
-          _vitest.expect.call(void 0, error.message).toBe(_chunkSNAUKDDKcjs.INTERNAL_ERROR_DESCRIPTION);
+          _vitest.expect.call(void 0, error.code).toBe(_chunk2XQS746Mcjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunk2XQS746Mcjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -2384,50 +2258,50 @@ function runActorOnStateChangeTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor onStateChange Tests", () => {
     _vitest.test.call(void 0, "triggers onStateChange when state is modified", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.onStateChangeActor.getOrCreate();
-      await actor2.setValue(10);
-      const changeCount = await actor2.getChangeCount();
+      const actor = client.onStateChangeActor.getOrCreate();
+      await actor.setValue(10);
+      const changeCount = await actor.getChangeCount();
       _vitest.expect.call(void 0, changeCount).toBe(1);
     });
     _vitest.test.call(void 0, "triggers onChange multiple times for multiple state changes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.onStateChangeActor.getOrCreate();
-      await actor2.incrementMultiple(3);
-      const changeCount = await actor2.getChangeCount();
+      const actor = client.onStateChangeActor.getOrCreate();
+      await actor.incrementMultiple(3);
+      const changeCount = await actor.getChangeCount();
       _vitest.expect.call(void 0, changeCount).toBe(3);
     });
     _vitest.test.call(void 0, "does NOT trigger onChange for read-only actions", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.onStateChangeActor.getOrCreate();
-      await actor2.setValue(5);
-      const value = await actor2.getValue();
+      const actor = client.onStateChangeActor.getOrCreate();
+      await actor.setValue(5);
+      const value = await actor.getValue();
       _vitest.expect.call(void 0, value).toBe(5);
-      const changeCount = await actor2.getChangeCount();
+      const changeCount = await actor.getChangeCount();
       _vitest.expect.call(void 0, changeCount).toBe(1);
     });
     _vitest.test.call(void 0, "does NOT trigger onChange for computed values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.onStateChangeActor.getOrCreate();
-      await actor2.setValue(3);
+      const actor = client.onStateChangeActor.getOrCreate();
+      await actor.setValue(3);
       {
-        const changeCount = await actor2.getChangeCount();
+        const changeCount = await actor.getChangeCount();
         _vitest.expect.call(void 0, changeCount).toBe(1);
       }
-      const doubled = await actor2.getDoubled();
+      const doubled = await actor.getDoubled();
       _vitest.expect.call(void 0, doubled).toBe(6);
       {
-        const changeCount = await actor2.getChangeCount();
+        const changeCount = await actor.getChangeCount();
         _vitest.expect.call(void 0, changeCount).toBe(1);
       }
     });
     _vitest.test.call(void 0, "simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.onStateChangeActor.getOrCreate();
-      const connection = await actor2.connect();
+      const actor = client.onStateChangeActor.getOrCreate();
+      const connection = await actor.connect();
       const value = await connection.getValue();
       _vitest.expect.call(void 0, value).toBe(0);
       await connection.dispose();
-      const changeCount = await actor2.getChangeCount();
+      const changeCount = await actor.getChangeCount();
       _vitest.expect.call(void 0, changeCount).toBe(0);
     });
   });
@@ -2581,17 +2455,17 @@ function runManagerDriverTests(driverTestConfig) {
           value: 42,
           nested: { foo: "bar" }
         };
-        const actor2 = await client.inputActor.create(void 0, {
+        const actor = await client.inputActor.create(void 0, {
           input: testInput
         });
-        const inputs = await actor2.getInputs();
+        const inputs = await actor.getInputs();
         _vitest.expect.call(void 0, inputs.initialInput).toEqual(testInput);
         _vitest.expect.call(void 0, inputs.onCreateInput).toEqual(testInput);
       });
       _vitest.test.call(void 0, "input is undefined when not provided", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor2 = await client.inputActor.create();
-        const inputs = await actor2.getInputs();
+        const actor = await client.inputActor.create();
+        const inputs = await actor.getInputs();
         _vitest.expect.call(void 0, inputs.initialInput).toBeUndefined();
         _vitest.expect.call(void 0, inputs.onCreateInput).toBeUndefined();
       });
@@ -2603,10 +2477,10 @@ function runManagerDriverTests(driverTestConfig) {
           value: 100,
           nested: { baz: "qux" }
         };
-        const actor2 = client.inputActor.getOrCreate(uniqueKey, {
+        const actor = client.inputActor.getOrCreate(uniqueKey, {
           createWithInput: testInput
         });
-        const inputs = await actor2.getInputs();
+        const inputs = await actor.getInputs();
         _vitest.expect.call(void 0, inputs.initialInput).toEqual(testInput);
         _vitest.expect.call(void 0, inputs.onCreateInput).toEqual(testInput);
         const existingActor = client.inputActor.getOrCreate(uniqueKey);
@@ -2721,17 +2595,17 @@ function runRawHttpTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw http", () => {
     _vitest.test.call(void 0, "should handle raw HTTP GET requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["test"]);
-      const helloResponse = await actor2.fetch("api/hello");
+      const actor = client.rawHttpActor.getOrCreate(["test"]);
+      const helloResponse = await actor.fetch("api/hello");
       _vitest.expect.call(void 0, helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
       _vitest.expect.call(void 0, helloData).toEqual({ message: "Hello from actor!" });
     });
     _vitest.test.call(void 0, "should handle raw HTTP POST requests with echo", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["test"]);
+      const actor = client.rawHttpActor.getOrCreate(["test"]);
       const testData = { test: "data", number: 123 };
-      const echoResponse = await actor2.fetch("api/echo", {
+      const echoResponse = await actor.fetch("api/echo", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -2744,23 +2618,23 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should track state across raw HTTP requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["state-test"]);
-      await actor2.fetch("api/hello");
-      await actor2.fetch("api/hello");
-      await actor2.fetch("api/state");
-      const stateResponse = await actor2.fetch("api/state");
+      const actor = client.rawHttpActor.getOrCreate(["state-test"]);
+      await actor.fetch("api/hello");
+      await actor.fetch("api/hello");
+      await actor.fetch("api/state");
+      const stateResponse = await actor.fetch("api/state");
       _vitest.expect.call(void 0, stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
       _vitest.expect.call(void 0, stateData.requestCount).toBe(4);
     });
     _vitest.test.call(void 0, "should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["headers-test"]);
+      const actor = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
         "X-Custom-Header": "test-value",
         "X-Another-Header": "another-value"
       };
-      const response = await actor2.fetch("api/headers", {
+      const response = await actor.fetch("api/headers", {
         headers: customHeaders
       });
       _vitest.expect.call(void 0, response.ok).toBe(true);
@@ -2770,26 +2644,26 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should return 404 for unhandled paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["404-test"]);
-      const response = await actor2.fetch("api/nonexistent");
+      const actor = client.rawHttpActor.getOrCreate(["404-test"]);
+      const response = await actor.fetch("api/nonexistent");
       _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 404 when no onRequest handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpNoHandlerActor.getOrCreate([
+      const actor = client.rawHttpNoHandlerActor.getOrCreate([
         "no-handler"
       ]);
-      const response = await actor2.fetch("api/anything");
+      const response = await actor.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 onRequest returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpVoidReturnActor.getOrCreate([
+      const actor = client.rawHttpVoidReturnActor.getOrCreate([
         "void-return"
       ]);
-      const response = await actor2.fetch("api/anything");
+      const response = await actor.fetch("api/anything");
       _vitest.expect.call(void 0, response.ok).toBe(false);
       _vitest.expect.call(void 0, response.status).toBe(500);
       try {
@@ -2797,15 +2671,15 @@ function runRawHttpTests(driverTestConfig) {
         _vitest.expect.call(void 0, errorData.message).toContain(
           "onRequest handler must return a Response"
         );
-      } catch (e3) {
+      } catch (e2) {
       }
     });
     _vitest.test.call(void 0, "should handle different HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["methods-test"]);
+      const actor = client.rawHttpActor.getOrCreate(["methods-test"]);
       const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
       for (const method of methods) {
-        const response = await actor2.fetch("api/echo", {
+        const response = await actor.fetch("api/echo", {
           method,
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
@@ -2822,9 +2696,9 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["binary-test"]);
+      const actor = client.rawHttpActor.getOrCreate(["binary-test"]);
       const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
-      const response = await actor2.fetch("api/echo", {
+      const response = await actor.fetch("api/echo", {
         method: "POST",
         headers: {
           "Content-Type": "application/octet-stream"
@@ -2838,24 +2712,24 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should work with Hono router using createVars", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
-      const rootResponse = await actor2.fetch("/");
+      const actor = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
+      const rootResponse = await actor.fetch("/");
       _vitest.expect.call(void 0, rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
       _vitest.expect.call(void 0, rootData).toEqual({ message: "Welcome to Hono actor!" });
-      const usersResponse = await actor2.fetch("/users");
+      const usersResponse = await actor.fetch("/users");
       _vitest.expect.call(void 0, usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
       _vitest.expect.call(void 0, users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
-      const userResponse = await actor2.fetch("/users/1");
+      const userResponse = await actor.fetch("/users/1");
       _vitest.expect.call(void 0, userResponse.ok).toBe(true);
       const user = await userResponse.json();
       _vitest.expect.call(void 0, user).toEqual({ id: 1, name: "Alice" });
       const newUser = { name: "Charlie" };
-      const createResponse = await actor2.fetch("/users", {
+      const createResponse = await actor.fetch("/users", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(newUser)
@@ -2865,7 +2739,7 @@ function runRawHttpTests(driverTestConfig) {
       const createdUser = await createResponse.json();
       _vitest.expect.call(void 0, createdUser).toEqual({ id: 3, name: "Charlie" });
       const updateData = { name: "Alice Updated" };
-      const updateResponse = await actor2.fetch("/users/1", {
+      const updateResponse = await actor.fetch("/users/1", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(updateData)
@@ -2873,32 +2747,32 @@ function runRawHttpTests(driverTestConfig) {
       _vitest.expect.call(void 0, updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
       _vitest.expect.call(void 0, updatedUser).toEqual({ id: 1, name: "Alice Updated" });
-      const deleteResponse = await actor2.fetch("/users/2", {
+      const deleteResponse = await actor.fetch("/users/2", {
         method: "DELETE"
       });
       _vitest.expect.call(void 0, deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
       _vitest.expect.call(void 0, deleteResult).toEqual({ message: "User 2 deleted" });
-      const notFoundResponse = await actor2.fetch("/api/unknown");
+      const notFoundResponse = await actor.fetch("/api/unknown");
       _vitest.expect.call(void 0, notFoundResponse.ok).toBe(false);
       _vitest.expect.call(void 0, notFoundResponse.status).toBe(404);
     });
     _vitest.test.call(void 0, "should handle paths with and without leading slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["path-test"]);
-      const responseWithoutSlash = await actor2.fetch("api/hello");
+      const actor = client.rawHttpActor.getOrCreate(["path-test"]);
+      const responseWithoutSlash = await actor.fetch("api/hello");
       _vitest.expect.call(void 0, responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
       _vitest.expect.call(void 0, dataWithoutSlash).toEqual({ message: "Hello from actor!" });
-      const responseWithSlash = await actor2.fetch("/api/hello");
+      const responseWithSlash = await actor.fetch("/api/hello");
       _vitest.expect.call(void 0, responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
       _vitest.expect.call(void 0, dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
     _vitest.test.call(void 0, "should not create double slashes in request URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpHonoActor.getOrCreate(["url-test"]);
-      const response = await actor2.fetch("/users");
+      const actor = client.rawHttpHonoActor.getOrCreate(["url-test"]);
+      const response = await actor.fetch("/users");
       _vitest.expect.call(void 0, response.ok).toBe(true);
       const data = await response.json();
       _vitest.expect.call(void 0, data).toEqual([
@@ -2908,13 +2782,13 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle forwarded requests correctly without double slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
+      const actor = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
       const truncatedPath = "/users";
       const url = new URL(truncatedPath, "http://example.com");
       const newRequest = new Request(url, {
         method: "GET"
       });
-      const response = await actor2.fetch(
+      const response = await actor.fetch(
         truncatedPath,
         newRequest
       );
@@ -2927,22 +2801,22 @@ function runRawHttpTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "example fix: should properly forward requests using just Request object", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
+      const actor = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
       const truncatedPath = "/users/1";
       const url = new URL(truncatedPath, "http://example.com");
       const newRequest = new Request(url, {
         method: "GET"
       });
-      const response = await actor2.fetch(newRequest);
+      const response = await actor.fetch(newRequest);
       _vitest.expect.call(void 0, response.ok).toBe(true);
       const user = await response.json();
       _vitest.expect.call(void 0, user).toEqual({ id: 1, name: "Alice" });
     });
     _vitest.test.call(void 0, "should support standard fetch API with URL and Request objects", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
+      const actor = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
       const url = new URL("/api/echo", "http://example.com");
-      const urlResponse = await actor2.fetch(url, {
+      const urlResponse = await actor.fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
@@ -2955,7 +2829,7 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "Request object" })
       });
-      const requestResponse = await actor2.fetch(request);
+      const requestResponse = await actor.fetch(request);
       _vitest.expect.call(void 0, requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
       _vitest.expect.call(void 0, requestData).toEqual({ from: "Request object" });
@@ -2963,7 +2837,7 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET",
         headers: { "X-Original": "request-header" }
       });
-      const overrideResponse = await actor2.fetch(request2, {
+      const overrideResponse = await actor.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
       _vitest.expect.call(void 0, overrideResponse.ok).toBe(true);
@@ -2980,10 +2854,10 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw http request properties", () => {
     _vitest.test.call(void 0, "should pass all Request properties correctly to onRequest", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/path?foo=bar&baz=qux", {
+      const response = await actor.fetch("test/path?foo=bar&baz=qux", {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -3009,10 +2883,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/get", {
+      const response = await actor.fetch("test/get", {
         method: "GET"
       });
       _vitest.expect.call(void 0, response.ok).toBe(true);
@@ -3022,13 +2896,13 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const formData = new URLSearchParams();
       formData.append("field1", "value1");
       formData.append("field2", "value2");
-      const formResponse = await actor2.fetch("test/form", {
+      const formResponse = await actor.fetch("test/form", {
         method: "POST",
         headers: {
           "Content-Type": "application/x-www-form-urlencoded"
@@ -3041,7 +2915,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         "application/x-www-form-urlencoded"
       );
       _vitest.expect.call(void 0, formResult.bodyText).toBe("field1=value1&field2=value2");
-      const textResponse = await actor2.fetch("test/text", {
+      const textResponse = await actor.fetch("test/text", {
         method: "POST",
         headers: {
           "Content-Type": "text/plain"
@@ -3055,10 +2929,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/headers", {
+      const response = await actor.fetch("test/headers", {
         headers: {
           Accept: "application/json",
           "Accept-Language": "en-US,en;q=0.9",
@@ -3077,14 +2951,14 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const rootResponse = await actor2.fetch("");
+      const rootResponse = await actor.fetch("");
       _vitest.expect.call(void 0, rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
       _vitest.expect.call(void 0, rootData.pathname).toBe("/");
-      const specialResponse = await actor2.fetch(
+      const specialResponse = await actor.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
       _vitest.expect.call(void 0, specialResponse.ok).toBe(true);
@@ -3092,7 +2966,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       _vitest.expect.call(void 0, specialData.pathname).toMatch(
         /path.*with.*spaces.*and.*slashes/
       );
-      const fragmentResponse = await actor2.fetch("test/path#fragment");
+      const fragmentResponse = await actor.fetch("test/path#fragment");
       _vitest.expect.call(void 0, fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
       _vitest.expect.call(void 0, fragmentData.pathname).toBe("/test/path");
@@ -3100,7 +2974,7 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const methods = [
@@ -3113,7 +2987,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         "OPTIONS"
       ];
       for (const method of methods) {
-        const response = await actor2.fetch(
+        const response = await actor.fetch(
           `test/${method.toLowerCase()}`,
           {
             method,
@@ -3138,10 +3012,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch(
+      const response = await actor.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
       _vitest.expect.call(void 0, response.ok).toBe(true);
@@ -3152,7 +3026,7 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const boundary = "----RivetKitBoundary";
@@ -3167,7 +3041,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         "value2",
         `------${boundary}--`
       ].join("\r\n");
-      const response = await actor2.fetch("test/multipart", {
+      const response = await actor.fetch("test/multipart", {
         method: "POST",
         headers: {
           "Content-Type": `multipart/form-data; boundary=----${boundary}`
@@ -3184,11 +3058,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle very long URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const longValue = "x".repeat(1e3);
-      const response = await actor2.fetch(`test/long?param=${longValue}`);
+      const response = await actor.fetch(`test/long?param=${longValue}`);
       _vitest.expect.call(void 0, response.ok).toBe(true);
       const data = await response.json();
       _vitest.expect.call(void 0, data.searchParams.param).toBe(longValue);
@@ -3196,7 +3070,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
     });
     _vitest.test.skip("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const largeArray = new Array(1e4).fill({
@@ -3204,7 +3078,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         name: "Test",
         description: "This is a test object with some data"
       });
-      const response = await actor2.fetch("test/large", {
+      const response = await actor.fetch("test/large", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -3217,10 +3091,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/no-content-type", {
+      const response = await actor.fetch("test/no-content-type", {
         method: "POST",
         body: "plain text without content-type"
       });
@@ -3230,10 +3104,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/empty", {
+      const response = await actor.fetch("test/empty", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -3244,11 +3118,11 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       try {
-        const response = await actor2.fetch("test/custom", {
+        const response = await actor.fetch("test/custom", {
           method: "CUSTOM"
         });
         if (response.ok) {
@@ -3260,10 +3134,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch("test/cookies", {
+      const response = await actor.fetch("test/cookies", {
         headers: {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
@@ -3276,10 +3150,10 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
-      const response = await actor2.fetch(
+      const response = await actor.fetch(
         "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
       );
       _vitest.expect.call(void 0, response.ok).toBe(true);
@@ -3290,21 +3164,21 @@ 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([
+      const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const requests = [
-        actor2.fetch("test/concurrent?id=1", {
+        actor.fetch("test/concurrent?id=1", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ request: 1 })
         }),
-        actor2.fetch("test/concurrent?id=2", {
+        actor.fetch("test/concurrent?id=2", {
           method: "PUT",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ request: 2 })
         }),
-        actor2.fetch("test/concurrent?id=3", {
+        actor.fetch("test/concurrent?id=3", {
           method: "DELETE"
         })
       ];
@@ -3331,8 +3205,8 @@ function runRawWebSocketTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw websocket", () => {
     _vitest.test.call(void 0, "should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
-      const ws = await actor2.websocket();
+      const actor = client.rawWebSocketActor.getOrCreate(["basic"]);
+      const ws = await actor.websocket();
       await new Promise((resolve) => {
         if (ws.readyState === WebSocket.OPEN) {
           resolve();
@@ -3362,8 +3236,8 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
-      const ws = await actor2.websocket();
+      const actor = client.rawWebSocketActor.getOrCreate(["echo"]);
+      const ws = await actor.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3393,8 +3267,8 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
-      const ws = await actor2.websocket();
+      const actor = client.rawWebSocketActor.getOrCreate(["ping"]);
+      const ws = await actor.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3475,10 +3349,10 @@ 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([
+      const actor = client.rawWebSocketBinaryActor.getOrCreate([
         "binary"
       ]);
-      const ws = await actor2.websocket();
+      const ws = await actor.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3522,8 +3396,8 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should work with custom paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate(["paths"]);
-      const ws = await actor2.websocket("custom/path");
+      const actor = client.rawWebSocketActor.getOrCreate(["paths"]);
+      const ws = await actor.websocket("custom/path");
       await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => {
           resolve();
@@ -3545,8 +3419,8 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle connection close properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate(["close-test"]);
-      const ws = await actor2.websocket();
+      const actor = client.rawWebSocketActor.getOrCreate(["close-test"]);
+      const ws = await actor.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
         await new Promise((resolve, reject) => {
           ws.addEventListener("open", () => resolve(), {
@@ -3555,7 +3429,7 @@ function runRawWebSocketTests(driverTestConfig) {
           ws.addEventListener("close", reject);
         });
       }
-      const initialStats = await actor2.getStats();
+      const initialStats = await actor.getStats();
       _vitest.expect.call(void 0, initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve) => {
         ws.addEventListener("close", () => resolve(), { once: true });
@@ -3564,7 +3438,7 @@ function runRawWebSocketTests(driverTestConfig) {
       await closePromise;
       let finalStats;
       for (let i = 0; i < 20; i++) {
-        finalStats = await actor2.getStats();
+        finalStats = await actor.getStats();
         if (finalStats.connectionCount === 0) {
           break;
         }
@@ -3574,10 +3448,10 @@ 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([
+      const actor = client.rawWebSocketActor.getOrCreate([
         "open-close-test"
       ]);
-      const ws1 = await actor2.websocket();
+      const ws1 = await actor.websocket();
       await new Promise((resolve, reject) => {
         ws1.addEventListener("open", () => resolve(), { once: true });
         ws1.addEventListener("close", reject);
@@ -3594,7 +3468,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       _vitest.expect.call(void 0, welcome1.type).toBe("welcome");
       _vitest.expect.call(void 0, welcome1.connectionCount).toBe(1);
-      const ws2 = await actor2.websocket();
+      const ws2 = await actor.websocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
         ws2.addEventListener("close", reject);
@@ -3611,7 +3485,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       _vitest.expect.call(void 0, welcome2.type).toBe("welcome");
       _vitest.expect.call(void 0, welcome2.connectionCount).toBe(2);
-      const midStats = await actor2.getStats();
+      const midStats = await actor.getStats();
       _vitest.expect.call(void 0, midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve) => {
@@ -3619,7 +3493,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       let afterFirstClose;
       for (let i = 0; i < 20; i++) {
-        afterFirstClose = await actor2.getStats();
+        afterFirstClose = await actor.getStats();
         if (afterFirstClose.connectionCount === 1) {
           break;
         }
@@ -3632,7 +3506,7 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       let finalStats;
       for (let i = 0; i < 20; i++) {
-        finalStats = await actor2.getStats();
+        finalStats = await actor.getStats();
         if (finalStats.connectionCount === 0) {
           break;
         }
@@ -3642,10 +3516,10 @@ 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([
+      const actor = client.rawWebSocketActor.getOrCreate([
         "query-params"
       ]);
-      const ws = await actor2.websocket(
+      const ws = await actor.websocket(
         "api/v1/stream?token=abc123&user=test"
       );
       await new Promise((resolve, reject) => {
@@ -3670,10 +3544,10 @@ function runRawWebSocketTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "should handle query parameters on base websocket path (no subpath)", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor2 = client.rawWebSocketActor.getOrCreate([
+      const actor = client.rawWebSocketActor.getOrCreate([
         "base-path-query-params"
       ]);
-      const ws = await actor2.websocket("?token=secret&session=123");
+      const ws = await actor.websocket("?token=secret&session=123");
       await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => resolve(), { once: true });
         ws.addEventListener("error", reject);
@@ -3805,6 +3679,7 @@ function runDriverTests(driverTestConfigPartial) {
           runActorConnTests(driverTestConfig);
           runActorConnStateTests(driverTestConfig);
           runActorConnHibernationTests(driverTestConfig);
+          runConnErrorSerializationTests(driverTestConfig);
           runActorDestroyTests(driverTestConfig);
           runRequestAccessTests(driverTestConfig);
           runActorHandleTests(driverTestConfig);
@@ -3852,7 +3727,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     const parsedConfig = registry.parseConfig();
     const managerDriver = (_a = driver.manager) == null ? void 0 : _a.call(driver, parsedConfig);
     _invariant2.default.call(void 0, managerDriver, "missing manager driver");
-    const { router } = _chunkB5UXC4QVcjs.buildManagerRouter.call(void 0, 
+    const { router } = _chunkBEMEUFS2cjs.buildManagerRouter.call(void 0, 
       parsedConfig,
       managerDriver,
       () => upgradeWebSocket
@@ -3860,7 +3735,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
     managerDriver.setGetUpgradeWebSocket(() => upgradeWebSocket);
-    const port = await _chunkQDVKDX7Gcjs.getPort.call(void 0, );
+    const port = await _chunkROVVTBUEcjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",
@@ -3872,7 +3747,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     nodeWebSocket.injectWebSocket(server);
     const serverEndpoint = `http://127.0.0.1:${port}`;
-    logger().info({ msg: "test serer listening", port });
+    _chunkR33VIC3Wcjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
     const cleanup = async () => {
       await new Promise(
         (resolve) => server.close(() => resolve(void 0))