rivetkit 2.0.42 → 2.0.43-rc.1

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

@@ -2,21 +2,21 @@
 
 
 
-var _chunk2IJTYN6Kcjs = require('../chunk-2IJTYN6K.cjs');
+var _chunkR33VIC3Wcjs = require('../chunk-R33VIC3W.cjs');
 
 
-var _chunk3VP5CSHVcjs = require('../chunk-3VP5CSHV.cjs');
-require('../chunk-X35U3YNX.cjs');
-require('../chunk-RUW5CZ5Z.cjs');
+var _chunkROVVTBUEcjs = require('../chunk-ROVVTBUE.cjs');
+require('../chunk-MQ3PTGWH.cjs');
+require('../chunk-ETNL2HZL.cjs');
 
 
 
 
 
-var _chunkGD7UXGOEcjs = require('../chunk-GD7UXGOE.cjs');
+var _chunkYR6H6STIcjs = require('../chunk-YR6H6STI.cjs');
 
 
-var _chunkEJVBH5VFcjs = require('../chunk-EJVBH5VF.cjs');
+var _chunk3HKN5HQ7cjs = require('../chunk-3HKN5HQ7.cjs');
 
 
 
@@ -27,11 +27,11 @@ var _chunkEJVBH5VFcjs = require('../chunk-EJVBH5VF.cjs');
 
 
 
-var _chunkRZW2DNNDcjs = require('../chunk-RZW2DNND.cjs');
+var _chunkBEMEUFS2cjs = require('../chunk-BEMEUFS2.cjs');
 require('../chunk-KDFWJKMJ.cjs');
 
 
-var _chunkH4TB4X25cjs = require('../chunk-H4TB4X25.cjs');
+var _chunkYZZF7DEScjs = require('../chunk-YZZF7DES.cjs');
 
 
 
@@ -80,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;
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).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}`;
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "rewriting http url",
         from: oldUrl,
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkRZW2DNNDcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkBEMEUFS2cjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -109,7 +109,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkGD7UXGOEcjs.ActorError)(
+              throw new (0, _chunkYR6H6STIcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -117,7 +117,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkGD7UXGOEcjs.ActorError)) {
+          if (!(e instanceof _chunkYR6H6STIcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -126,33 +126,33 @@ function createTestInlineClientDriver(endpoint, encoding) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkEJVBH5VFcjs.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`
       );
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).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(_chunkRZW2DNNDcjs.WS_PROTOCOL_STANDARD);
-      protocols.push(`${_chunkRZW2DNNDcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(_chunkBEMEUFS2cjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunkBEMEUFS2cjs.WS_PROTOCOL_TARGET}actor`);
       protocols.push(
-        `${_chunkRZW2DNNDcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+        `${_chunkBEMEUFS2cjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
       );
-      protocols.push(`${_chunkRZW2DNNDcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkBEMEUFS2cjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunkRZW2DNNDcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunkBEMEUFS2cjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunkRZW2DNNDcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunkBEMEUFS2cjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
-      _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+      _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
         msg: "connecting to websocket",
         url: finalWsUrl,
         protocols
@@ -172,7 +172,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
         encoding2,
         params
       );
-      return upgradeWebSocket(() => wsHandler)(c, _chunkH4TB4X25cjs.noopNext.call(void 0, ));
+      return upgradeWebSocket(() => wsHandler)(c, _chunkYZZF7DEScjs.noopNext.call(void 0, ));
     },
     async buildGatewayUrl(actorId) {
       return `${endpoint}/gateway/${actorId}`;
@@ -189,7 +189,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
   };
 }
 async function makeInlineRequest(endpoint, encoding, method, args) {
-  _chunk2IJTYN6Kcjs.logger.call(void 0, ).debug({
+  _chunkR33VIC3Wcjs.logger.call(void 0, ).debug({
     msg: "sending inline request",
     encoding,
     method,
@@ -219,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, _chunkGD7UXGOEcjs.ActorError)(
+    throw new (0, _chunkYR6H6STIcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkBEMEUFS2cjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -239,12 +239,12 @@ async function setupDriverTest(c, driverTestConfig) {
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   c.onTestFinished(() => {
-    _chunk2IJTYN6Kcjs.logger.call(void 0, ).info("cleaning up test");
+    _chunkR33VIC3Wcjs.logger.call(void 0, ).info("cleaning up test");
     cleanup();
   });
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkGD7UXGOEcjs.createClient.call(void 0, {
+    client = _chunkYR6H6STIcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -257,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 = _chunkGD7UXGOEcjs.ClientConfigSchema.parse({
+    const runConfig = _chunkYR6H6STIcjs.ClientConfigSchema.parse({
       encoding
     });
-    client = _chunkGD7UXGOEcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkYR6H6STIcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkRZW2DNNDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkBEMEUFS2cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -796,7 +796,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
         _vitest.expect.call(void 0, ping2).toBe("pong");
@@ -818,7 +818,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
         _vitest.expect.call(void 0, count3).toBe(2);
@@ -840,7 +840,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await conn1.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunk2IJTYN6Kcjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkR33VIC3Wcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         await conn1.dispose();
         await waitFor(driverTestConfig, 250);
@@ -1046,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) {
@@ -1234,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) {
@@ -1325,7 +1459,7 @@ function runActorSleepTests(driverTestConfig) {
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1341,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, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1357,7 +1491,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1373,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, _chunk2IJTYN6Kcjs.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, _chunk2IJTYN6Kcjs.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, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1400,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(_chunk2IJTYN6Kcjs.SLEEP_TIMEOUT - 250);
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.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);
@@ -1416,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(_chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.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);
@@ -1437,7 +1571,7 @@ function runActorSleepTests(driverTestConfig) {
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       await sleepActor.finishLongRunningRpc();
       await longRunningPromise;
       {
@@ -1446,7 +1580,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1478,7 +1612,7 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      await waitFor(driverTestConfig, _chunk2IJTYN6Kcjs.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) => {
@@ -1491,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, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1509,7 +1643,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const fetchDuration = _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250;
+      const fetchDuration = _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
         `long-request?duration=${fetchDuration}`
       );
@@ -1522,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, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1537,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, _chunk2IJTYN6Kcjs.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, _chunk2IJTYN6Kcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkR33VIC3Wcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1596,6 +1730,7 @@ function runActorDriverTests(driverTestConfig) {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
     runActorSleepTests(driverTestConfig);
+    runActorLifecycleTests(driverTestConfig);
   });
 }
 
@@ -3544,6 +3679,7 @@ function runDriverTests(driverTestConfigPartial) {
           runActorConnTests(driverTestConfig);
           runActorConnStateTests(driverTestConfig);
           runActorConnHibernationTests(driverTestConfig);
+          runConnErrorSerializationTests(driverTestConfig);
           runActorDestroyTests(driverTestConfig);
           runRequestAccessTests(driverTestConfig);
           runActorHandleTests(driverTestConfig);
@@ -3591,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 } = _chunkRZW2DNNDcjs.buildManagerRouter.call(void 0, 
+    const { router } = _chunkBEMEUFS2cjs.buildManagerRouter.call(void 0, 
       parsedConfig,
       managerDriver,
       () => upgradeWebSocket
@@ -3599,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 _chunk3VP5CSHVcjs.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",
@@ -3611,7 +3747,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     nodeWebSocket.injectWebSocket(server);
     const serverEndpoint = `http://127.0.0.1:${port}`;
-    _chunk2IJTYN6Kcjs.logger.call(void 0, ).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))