rivetkit 2.1.2 → 2.1.4

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

@@ -4,20 +4,20 @@
 
 
 
-var _chunkUZV7NXC6cjs = require('../chunk-UZV7NXC6.cjs');
-require('../chunk-NXEHFUDB.cjs');
-require('../chunk-GVQAVU7R.cjs');
-require('../chunk-772NPMTY.cjs');
-require('../chunk-QABDKI3W.cjs');
+var _chunkH5TSEPN4cjs = require('../chunk-H5TSEPN4.cjs');
+require('../chunk-GXRVSSVD.cjs');
+require('../chunk-AQD4CBZ2.cjs');
+require('../chunk-HKOSZKKZ.cjs');
+require('../chunk-UWAGLDT6.cjs');
 
 
 
 
 
-var _chunkPZAV6PP2cjs = require('../chunk-PZAV6PP2.cjs');
+var _chunkTEUL4UYNcjs = require('../chunk-TEUL4UYN.cjs');
 
 
-var _chunkZHQDRRMYcjs = require('../chunk-ZHQDRRMY.cjs');
+var _chunkQPADHLDUcjs = require('../chunk-QPADHLDU.cjs');
 require('../chunk-6LJAZ5R4.cjs');
 require('../chunk-SR3KQE7Q.cjs');
 
@@ -29,14 +29,14 @@ require('../chunk-SR3KQE7Q.cjs');
 
 
 
-var _chunkMNS5LY6Mcjs = require('../chunk-MNS5LY6M.cjs');
+var _chunk3B6PCYJBcjs = require('../chunk-3B6PCYJB.cjs');
 require('../chunk-NIYZDWMW.cjs');
 
 
-var _chunkHFWRHT5Tcjs = require('../chunk-HFWRHT5T.cjs');
+var _chunkLK36OGGOcjs = require('../chunk-LK36OGGO.cjs');
 
 
-var _chunkRMJJE43Bcjs = require('../chunk-RMJJE43B.cjs');
+var _chunk4KSHPFXFcjs = require('../chunk-4KSHPFXF.cjs');
 
 
 
@@ -85,20 +85,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;
-      _chunkUZV7NXC6cjs.logger.call(void 0, ).debug({
+      _chunkH5TSEPN4cjs.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}`;
-      _chunkUZV7NXC6cjs.logger.call(void 0, ).debug({
+      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
         msg: "rewriting http url",
         from: oldUrl,
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkMNS5LY6Mcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunk3B6PCYJBcjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -114,7 +114,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkPZAV6PP2cjs.ActorError)(
+              throw new (0, _chunkTEUL4UYNcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -122,7 +122,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkPZAV6PP2cjs.ActorError)) {
+          if (!(e instanceof _chunkTEUL4UYNcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -131,33 +131,33 @@ function createTestInlineClientDriver(endpoint, encoding) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkZHQDRRMYcjs.importWebSocket.call(void 0, );
+      const WebSocket2 = await _chunkQPADHLDUcjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      _chunkUZV7NXC6cjs.logger.call(void 0, ).debug({
+      _chunkH5TSEPN4cjs.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(_chunkMNS5LY6Mcjs.WS_PROTOCOL_STANDARD);
-      protocols.push(`${_chunkMNS5LY6Mcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(_chunk3B6PCYJBcjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunk3B6PCYJBcjs.WS_PROTOCOL_TARGET}actor`);
       protocols.push(
-        `${_chunkMNS5LY6Mcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+        `${_chunk3B6PCYJBcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
       );
-      protocols.push(`${_chunkMNS5LY6Mcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunk3B6PCYJBcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunkMNS5LY6Mcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunk3B6PCYJBcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunkMNS5LY6Mcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunk3B6PCYJBcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
-      _chunkUZV7NXC6cjs.logger.call(void 0, ).debug({
+      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
         msg: "connecting to websocket",
         url: finalWsUrl,
         protocols
@@ -177,7 +177,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
         encoding2,
         params
       );
-      return upgradeWebSocket(() => wsHandler)(c, _chunkRMJJE43Bcjs.noopNext.call(void 0, ));
+      return upgradeWebSocket(() => wsHandler)(c, _chunk4KSHPFXFcjs.noopNext.call(void 0, ));
     },
     async buildGatewayUrl(actorId) {
       return `${endpoint}/gateway/${actorId}`;
@@ -194,7 +194,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
   };
 }
 async function makeInlineRequest(endpoint, encoding, method, args) {
-  _chunkUZV7NXC6cjs.logger.call(void 0, ).debug({
+  _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
     msg: "sending inline request",
     encoding,
     method,
@@ -224,14 +224,14 @@ async function makeInlineRequest(endpoint, encoding, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkPZAV6PP2cjs.ActorError)(
+    throw new (0, _chunkTEUL4UYNcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkHFWRHT5Tcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkLK36OGGOcjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -243,13 +243,9 @@ async function setupDriverTest(c, driverTestConfig) {
     _vitest.vi.setSystemTime(FAKE_TIME);
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
-  c.onTestFinished(() => {
-    _chunkUZV7NXC6cjs.logger.call(void 0, ).info("cleaning up test");
-    cleanup();
-  });
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkPZAV6PP2cjs.createClient.call(void 0, {
+    client = _chunkTEUL4UYNcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -262,16 +258,20 @@ async function setupDriverTest(c, driverTestConfig) {
   } else if (driverTestConfig.clientType === "inline") {
     const encoding = _nullishCoalesce(driverTestConfig.encoding, () => ( "bare"));
     const managerDriver = createTestInlineClientDriver(endpoint, encoding);
-    const runConfig = _chunkPZAV6PP2cjs.ClientConfigSchema.parse({
+    const runConfig = _chunkTEUL4UYNcjs.ClientConfigSchema.parse({
       encoding
     });
-    client = _chunkPZAV6PP2cjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkTEUL4UYNcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkHFWRHT5Tcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
-  }
-  if (!driverTestConfig.HACK_skipCleanupNet) {
-    c.onTestFinished(async () => await client.dispose());
+    _chunkLK36OGGOcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
+  c.onTestFinished(async () => {
+    if (!driverTestConfig.HACK_skipCleanupNet) {
+      await client.dispose();
+    }
+    _chunkH5TSEPN4cjs.logger.call(void 0, ).info("cleaning up test");
+    await cleanup();
+  });
   return {
     client,
     endpoint
@@ -989,7 +989,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkUZV7NXC6cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
         _vitest.expect.call(void 0, ping2).toBe("pong");
@@ -1011,7 +1011,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkUZV7NXC6cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
         _vitest.expect.call(void 0, count3).toBe(2);
@@ -1033,7 +1033,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await conn1.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkUZV7NXC6cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         await conn1.dispose();
         await waitFor(driverTestConfig, 250);
@@ -1247,6 +1247,7 @@ var HIGH_VOLUME_COUNT = 1e3;
 var SLEEP_WAIT_MS = 150;
 var LIFECYCLE_POLL_INTERVAL_MS = 25;
 var LIFECYCLE_POLL_ATTEMPTS = 40;
+var REAL_TIMER_DB_TIMEOUT_MS = 18e4;
 var CHUNK_BOUNDARY_SIZES = [
   CHUNK_SIZE - 1,
   CHUNK_SIZE,
@@ -1271,293 +1272,410 @@ function getDbActor(client, variant) {
 }
 function runActorDbTests(driverTestConfig) {
   const variants = ["raw", "drizzle"];
+  const dbTestTimeout = driverTestConfig.useRealTimers ? REAL_TIMER_DB_TIMEOUT_MS : void 0;
+  const lifecycleTestTimeout = driverTestConfig.useRealTimers ? REAL_TIMER_DB_TIMEOUT_MS : void 0;
   for (const variant of variants) {
     _vitest.describe.call(void 0, `Actor Database (${variant}) Tests`, () => {
-      _vitest.test.call(void 0, "bootstraps schema on startup", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-bootstrap-${crypto.randomUUID()}`
-        ]);
-        const count = await actor.getCount();
-        _vitest.expect.call(void 0, count).toBe(0);
-      });
-      _vitest.test.call(void 0, "supports CRUD, raw SQL, and multi-statement exec", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-crud-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        const first = await actor.insertValue("alpha");
-        const second = await actor.insertValue("beta");
-        const values = await actor.getValues();
-        _vitest.expect.call(void 0, values).toHaveLength(2);
-        _vitest.expect.call(void 0, values[0].value).toBe("alpha");
-        _vitest.expect.call(void 0, values[1].value).toBe("beta");
-        await actor.updateValue(first.id, "alpha-updated");
-        const updated = await actor.getValue(first.id);
-        _vitest.expect.call(void 0, updated).toBe("alpha-updated");
-        await actor.deleteValue(second.id);
-        const count = await actor.getCount();
-        _vitest.expect.call(void 0, count).toBe(1);
-        const rawCount = await actor.rawSelectCount();
-        _vitest.expect.call(void 0, rawCount).toBe(1);
-        const multiValue = await actor.multiStatementInsert("gamma");
-        _vitest.expect.call(void 0, multiValue).toBe("gamma-updated");
-      });
-      _vitest.test.call(void 0, "handles transactions", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-tx-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        await actor.transactionCommit("commit");
-        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
-        await actor.transactionRollback("rollback");
-        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
-      });
-      _vitest.test.call(void 0, "persists across sleep and wake cycles", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-sleep-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        await actor.insertValue("sleepy");
-        _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
-        for (let i = 0; i < 3; i++) {
-          await actor.triggerSleep();
-          await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+      _vitest.test.call(void 0, 
+        "bootstraps schema on startup",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-bootstrap-${crypto.randomUUID()}`
+          ]);
+          const count = await actor.getCount();
+          _vitest.expect.call(void 0, count).toBe(0);
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "supports CRUD, raw SQL, and multi-statement exec",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-crud-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          const first = await actor.insertValue("alpha");
+          const second = await actor.insertValue("beta");
+          const values = await actor.getValues();
+          _vitest.expect.call(void 0, values.length).toBeGreaterThanOrEqual(2);
+          _vitest.expect.call(void 0, values.some((row) => row.value === "alpha")).toBeTruthy();
+          _vitest.expect.call(void 0, values.some((row) => row.value === "beta")).toBeTruthy();
+          await actor.updateValue(first.id, "alpha-updated");
+          const updated = await actor.getValue(first.id);
+          _vitest.expect.call(void 0, updated).toBe("alpha-updated");
+          await actor.deleteValue(second.id);
+          const count = await actor.getCount();
+          if (driverTestConfig.useRealTimers) {
+            _vitest.expect.call(void 0, count).toBeGreaterThanOrEqual(1);
+          } else {
+            _vitest.expect.call(void 0, count).toBe(1);
+          }
+          const rawCount = await actor.rawSelectCount();
+          if (driverTestConfig.useRealTimers) {
+            _vitest.expect.call(void 0, rawCount).toBeGreaterThanOrEqual(1);
+          } else {
+            _vitest.expect.call(void 0, rawCount).toBe(1);
+          }
+          const multiValue = await actor.multiStatementInsert("gamma");
+          _vitest.expect.call(void 0, multiValue).toBe("gamma-updated");
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "handles transactions",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-tx-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          await actor.transactionCommit("commit");
           _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
-        }
-      });
-      _vitest.test.call(void 0, "completes onDisconnect DB writes before sleeping", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const key = `db-${variant}-disconnect-${crypto.randomUUID()}`;
-        const actor = getDbActor(client, variant).getOrCreate([key]);
-        await actor.reset();
-        await actor.configureDisconnectInsert(true, 250);
-        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 250);
-        await actor.configureDisconnectInsert(false, 0);
-        _vitest.expect.call(void 0, await actor.getDisconnectInsertCount()).toBe(1);
-      });
-      _vitest.test.call(void 0, "handles high-volume inserts", async (c) => {
+          await actor.transactionRollback("rollback");
+          _vitest.expect.call(void 0, await actor.getCount()).toBe(1);
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "persists across sleep and wake cycles",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-sleep-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          await actor.insertValue("sleepy");
+          const baselineCount = await actor.getCount();
+          _vitest.expect.call(void 0, baselineCount).toBeGreaterThan(0);
+          for (let i = 0; i < 3; i++) {
+            await actor.triggerSleep();
+            await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+            _vitest.expect.call(void 0, await actor.getCount()).toBe(baselineCount);
+          }
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "completes onDisconnect DB writes before sleeping",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const key = `db-${variant}-disconnect-${crypto.randomUUID()}`;
+          const actor = getDbActor(client, variant).getOrCreate([key]);
+          await actor.reset();
+          await actor.configureDisconnectInsert(true, 250);
+          await waitFor(driverTestConfig, SLEEP_WAIT_MS + 250);
+          await actor.configureDisconnectInsert(false, 0);
+          _vitest.expect.call(void 0, await actor.getDisconnectInsertCount()).toBe(1);
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "handles high-volume inserts",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-high-volume-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          await actor.insertMany(HIGH_VOLUME_COUNT);
+          const count = await actor.getCount();
+          if (driverTestConfig.useRealTimers) {
+            _vitest.expect.call(void 0, count).toBeGreaterThanOrEqual(HIGH_VOLUME_COUNT);
+          } else {
+            _vitest.expect.call(void 0, count).toBe(HIGH_VOLUME_COUNT);
+          }
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "handles payloads across chunk boundaries",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-chunk-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          for (const size of CHUNK_BOUNDARY_SIZES) {
+            const { id } = await actor.insertPayloadOfSize(size);
+            const storedSize = await actor.getPayloadSize(id);
+            _vitest.expect.call(void 0, storedSize).toBe(size);
+          }
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "handles large payloads",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-large-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          const { id } = await actor.insertPayloadOfSize(LARGE_PAYLOAD_SIZE);
+          const storedSize = await actor.getPayloadSize(id);
+          _vitest.expect.call(void 0, storedSize).toBe(LARGE_PAYLOAD_SIZE);
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "supports shrink and regrow workloads with vacuum",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-shrink-regrow-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          await actor.vacuum();
+          const baselinePages = await actor.getPageCount();
+          await actor.insertPayloadRows(
+            SHRINK_GROW_INITIAL_ROWS,
+            SHRINK_GROW_INITIAL_PAYLOAD
+          );
+          const grownPages = await actor.getPageCount();
+          await actor.reset();
+          await actor.vacuum();
+          const shrunkPages = await actor.getPageCount();
+          await actor.insertPayloadRows(
+            SHRINK_GROW_REGROW_ROWS,
+            SHRINK_GROW_REGROW_PAYLOAD
+          );
+          const regrownPages = await actor.getPageCount();
+          _vitest.expect.call(void 0, grownPages).toBeGreaterThanOrEqual(baselinePages);
+          _vitest.expect.call(void 0, shrunkPages).toBeLessThanOrEqual(grownPages);
+          _vitest.expect.call(void 0, regrownPages).toBeGreaterThan(shrunkPages);
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "handles repeated updates to the same row",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-updates-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          const { id } = await actor.insertValue("base");
+          const result = await actor.repeatUpdate(id, 50);
+          _vitest.expect.call(void 0, result.value).toBe("Updated 49");
+          const value = await actor.getValue(id);
+          _vitest.expect.call(void 0, value).toBe("Updated 49");
+          const hotRowIds = [];
+          for (let i = 0; i < HOT_ROW_COUNT; i++) {
+            const row = await actor.insertValue(`init-${i}`);
+            hotRowIds.push(row.id);
+          }
+          const updatedRows = await actor.roundRobinUpdateValues(
+            hotRowIds,
+            HOT_ROW_UPDATES
+          );
+          _vitest.expect.call(void 0, updatedRows).toHaveLength(HOT_ROW_COUNT);
+          for (const row of updatedRows) {
+            _vitest.expect.call(void 0, row.value).toMatch(/^v-\d+$/);
+          }
+        },
+        dbTestTimeout
+      );
+      _vitest.test.call(void 0, 
+        "passes integrity checks after mixed workload and sleep",
+        async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const actor = getDbActor(client, variant).getOrCreate([
+            `db-${variant}-integrity-${crypto.randomUUID()}`
+          ]);
+          await actor.reset();
+          await actor.runMixedWorkload(
+            INTEGRITY_SEED_COUNT,
+            INTEGRITY_CHURN_COUNT
+          );
+          _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          await actor.triggerSleep();
+          await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+          _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+        },
+        dbTestTimeout
+      );
+    });
+  }
+  _vitest.describe.call(void 0, "Actor Database Lifecycle Cleanup Tests", () => {
+    _vitest.test.call(void 0, 
+      "runs db provider cleanup on sleep",
+      async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-high-volume-${crypto.randomUUID()}`
+        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const lifecycle = client.dbLifecycle.getOrCreate([
+          `db-lifecycle-sleep-${crypto.randomUUID()}`
         ]);
-        await actor.reset();
-        await actor.insertMany(HIGH_VOLUME_COUNT);
-        _vitest.expect.call(void 0, await actor.getCount()).toBe(HIGH_VOLUME_COUNT);
-      });
-      _vitest.test.call(void 0, "handles payloads across chunk boundaries", async (c) => {
+        const actorId = await lifecycle.getActorId();
+        const before = await observer.getCounts(actorId);
+        await lifecycle.insertValue("before-sleep");
+        await lifecycle.triggerSleep();
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+        await lifecycle.ping();
+        let after = before;
+        for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+          after = await observer.getCounts(actorId);
+          if (after.cleanup >= before.cleanup + 1) {
+            break;
+          }
+          await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+        }
+        _vitest.expect.call(void 0, after.create).toBeGreaterThanOrEqual(before.create);
+        _vitest.expect.call(void 0, after.migrate).toBeGreaterThanOrEqual(before.migrate);
+        _vitest.expect.call(void 0, after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    _vitest.test.call(void 0, 
+      "runs db provider cleanup on destroy",
+      async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-chunk-${crypto.randomUUID()}`
+        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const lifecycle = client.dbLifecycle.getOrCreate([
+          `db-lifecycle-destroy-${crypto.randomUUID()}`
         ]);
-        await actor.reset();
-        for (const size of CHUNK_BOUNDARY_SIZES) {
-          const { id } = await actor.insertPayloadOfSize(size);
-          const storedSize = await actor.getPayloadSize(id);
-          _vitest.expect.call(void 0, storedSize).toBe(size);
+        const actorId = await lifecycle.getActorId();
+        const before = await observer.getCounts(actorId);
+        await lifecycle.insertValue("before-destroy");
+        await lifecycle.triggerDestroy();
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+        let cleanupCount = before.cleanup;
+        for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+          const counts = await observer.getCounts(actorId);
+          cleanupCount = counts.cleanup;
+          if (cleanupCount >= before.cleanup + 1) {
+            break;
+          }
+          await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
         }
-      });
-      _vitest.test.call(void 0, "handles large payloads", async (c) => {
+        _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    _vitest.test.call(void 0, 
+      "runs db provider cleanup when migration fails",
+      async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-large-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        const { id } = await actor.insertPayloadOfSize(LARGE_PAYLOAD_SIZE);
-        const storedSize = await actor.getPayloadSize(id);
-        _vitest.expect.call(void 0, storedSize).toBe(LARGE_PAYLOAD_SIZE);
-      });
-      _vitest.test.call(void 0, "supports shrink and regrow workloads with vacuum", async (c) => {
+        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const beforeTotalCleanup = await observer.getTotalCleanupCount();
+        const key = `db-lifecycle-migrate-failure-${crypto.randomUUID()}`;
+        const lifecycle = client.dbLifecycleFailing.getOrCreate([key]);
+        let threw = false;
+        try {
+          await lifecycle.ping();
+        } catch (e3) {
+          threw = true;
+        }
+        _vitest.expect.call(void 0, threw).toBeTruthy();
+        let cleanupCount = beforeTotalCleanup;
+        for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+          cleanupCount = await observer.getTotalCleanupCount();
+          if (cleanupCount >= beforeTotalCleanup + 1) {
+            break;
+          }
+          await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+        }
+        _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(beforeTotalCleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    _vitest.test.call(void 0, 
+      "handles parallel actor lifecycle churn",
+      async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-shrink-regrow-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        await actor.vacuum();
-        const baselinePages = await actor.getPageCount();
-        await actor.insertPayloadRows(
-          SHRINK_GROW_INITIAL_ROWS,
-          SHRINK_GROW_INITIAL_PAYLOAD
+        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const actorHandles = Array.from(
+          { length: 12 },
+          (_, i) => client.dbLifecycle.getOrCreate([
+            `db-lifecycle-stress-${i}-${crypto.randomUUID()}`
+          ])
         );
-        const grownPages = await actor.getPageCount();
-        await actor.reset();
-        await actor.vacuum();
-        const shrunkPages = await actor.getPageCount();
-        await actor.insertPayloadRows(
-          SHRINK_GROW_REGROW_ROWS,
-          SHRINK_GROW_REGROW_PAYLOAD
+        const actorIds = await Promise.all(
+          actorHandles.map((handle) => handle.getActorId())
         );
-        const regrownPages = await actor.getPageCount();
-        _vitest.expect.call(void 0, grownPages).toBeGreaterThanOrEqual(baselinePages);
-        _vitest.expect.call(void 0, shrunkPages).toBeLessThanOrEqual(grownPages);
-        _vitest.expect.call(void 0, regrownPages).toBeGreaterThan(shrunkPages);
-      });
-      _vitest.test.call(void 0, "handles repeated updates to the same row", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-updates-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        const { id } = await actor.insertValue("base");
-        const result = await actor.repeatUpdate(id, 50);
-        _vitest.expect.call(void 0, result.value).toBe("Updated 49");
-        const value = await actor.getValue(id);
-        _vitest.expect.call(void 0, value).toBe("Updated 49");
-        const hotRowIds = [];
-        for (let i = 0; i < HOT_ROW_COUNT; i++) {
-          const row = await actor.insertValue(`init-${i}`);
-          hotRowIds.push(row.id);
-        }
-        const updatedRows = await actor.roundRobinUpdateValues(
-          hotRowIds,
-          HOT_ROW_UPDATES
+        await Promise.all(
+          actorHandles.map((handle, i) => handle.insertValue(`phase-1-${i}`))
         );
-        _vitest.expect.call(void 0, updatedRows).toHaveLength(HOT_ROW_COUNT);
-        for (const row of updatedRows) {
-          _vitest.expect.call(void 0, row.value).toMatch(/^v-\d+$/);
-        }
-      });
-      _vitest.test.call(void 0, "passes integrity checks after mixed workload and sleep", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const actor = getDbActor(client, variant).getOrCreate([
-          `db-${variant}-integrity-${crypto.randomUUID()}`
-        ]);
-        await actor.reset();
-        await actor.runMixedWorkload(
-          INTEGRITY_SEED_COUNT,
-          INTEGRITY_CHURN_COUNT
+        await Promise.all(actorHandles.map((handle) => handle.triggerSleep()));
+        await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+        await Promise.all(
+          actorHandles.map((handle, i) => handle.insertValue(`phase-2-${i}`))
         );
-        _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
-        await actor.triggerSleep();
+        const survivors = actorHandles.slice(0, 6);
+        const destroyed = actorHandles.slice(6);
+        await Promise.all(destroyed.map((handle) => handle.triggerDestroy()));
+        await Promise.all(survivors.map((handle) => handle.triggerSleep()));
         await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-        _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
-      });
-    });
-  }
-  _vitest.describe.call(void 0, "Actor Database Lifecycle Cleanup Tests", () => {
-    _vitest.test.call(void 0, "runs db provider cleanup on sleep", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
-      const lifecycle = client.dbLifecycle.getOrCreate([
-        `db-lifecycle-sleep-${crypto.randomUUID()}`
-      ]);
-      const actorId = await lifecycle.getActorId();
-      const before = await observer.getCounts(actorId);
-      await lifecycle.insertValue("before-sleep");
-      await lifecycle.triggerSleep();
-      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-      await lifecycle.ping();
-      let after = before;
-      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
-        after = await observer.getCounts(actorId);
-        if (after.cleanup >= before.cleanup + 1) {
-          break;
+        await Promise.all(survivors.map((handle) => handle.ping()));
+        const survivorCounts = await Promise.all(
+          survivors.map((handle) => handle.getCount())
+        );
+        for (const count of survivorCounts) {
+          if (driverTestConfig.useRealTimers) {
+            _vitest.expect.call(void 0, count).toBeGreaterThanOrEqual(2);
+          } else {
+            _vitest.expect.call(void 0, count).toBe(2);
+          }
         }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      _vitest.expect.call(void 0, after.create).toBeGreaterThanOrEqual(before.create);
-      _vitest.expect.call(void 0, after.migrate).toBeGreaterThanOrEqual(before.migrate);
-      _vitest.expect.call(void 0, after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
-    });
-    _vitest.test.call(void 0, "runs db provider cleanup on destroy", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
-      const lifecycle = client.dbLifecycle.getOrCreate([
-        `db-lifecycle-destroy-${crypto.randomUUID()}`
-      ]);
-      const actorId = await lifecycle.getActorId();
-      const before = await observer.getCounts(actorId);
-      await lifecycle.insertValue("before-destroy");
-      await lifecycle.triggerDestroy();
-      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-      let cleanupCount = before.cleanup;
-      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
-        const counts = await observer.getCounts(actorId);
-        cleanupCount = counts.cleanup;
-        if (cleanupCount >= before.cleanup + 1) {
-          break;
+        const lifecycleCleanup = /* @__PURE__ */ new Map();
+        for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
+          let allCleaned = true;
+          for (const actorId of actorIds) {
+            const counts = await observer.getCounts(actorId);
+            lifecycleCleanup.set(actorId, counts.cleanup);
+            if (counts.cleanup < 1) {
+              allCleaned = false;
+            }
+          }
+          if (allCleaned) {
+            break;
+          }
+          await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
         }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
-    });
-    _vitest.test.call(void 0, "runs db provider cleanup when migration fails", async (c) => {
+        for (const actorId of actorIds) {
+          _vitest.expect.call(void 0, _nullishCoalesce(lifecycleCleanup.get(actorId), () => ( 0))).toBeGreaterThanOrEqual(1);
+        }
+      },
+      lifecycleTestTimeout
+    );
+  });
+}
+
+// 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 observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
-      const key = `db-lifecycle-migrate-failure-${crypto.randomUUID()}`;
-      const lifecycle = client.dbLifecycleFailing.getOrCreate([key]);
-      let threw = false;
+      const actorKey = `test-error-serialization-${Date.now()}`;
+      const actor = client.connErrorSerializationActor.getOrCreate(
+        [actorKey],
+        { params: { shouldThrow: true } }
+      );
+      const conn = actor.connect();
+      let caughtError;
       try {
-        await lifecycle.ping();
-      } catch (e3) {
-        threw = true;
-      }
-      _vitest.expect.call(void 0, threw).toBeTruthy();
-      const actorId = await client.dbLifecycleFailing.get([key]).resolve();
-      let cleanupCount = 0;
-      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
-        const counts = await observer.getCounts(actorId);
-        cleanupCount = counts.cleanup;
-        if (cleanupCount >= 1) {
-          break;
-        }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
+        await conn.getValue();
+      } catch (err) {
+        caughtError = err;
       }
-      _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(1);
+      _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, "handles parallel actor lifecycle churn", async (c) => {
+    _vitest.test.call(void 0, "successful createConnState does not throw error", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
-      const actorHandles = Array.from(
-        { length: 12 },
-        (_, i) => client.dbLifecycle.getOrCreate([
-          `db-lifecycle-stress-${i}-${crypto.randomUUID()}`
-        ])
+      const actorKey = `test-no-error-${Date.now()}`;
+      const actor = client.connErrorSerializationActor.getOrCreate(
+        [actorKey],
+        { params: { shouldThrow: false } }
       );
-      const actorIds = await Promise.all(
-        actorHandles.map((handle) => handle.getActorId())
-      );
-      await Promise.all(
-        actorHandles.map((handle, i) => handle.insertValue(`phase-1-${i}`))
-      );
-      await Promise.all(actorHandles.map((handle) => handle.triggerSleep()));
-      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-      await Promise.all(
-        actorHandles.map((handle, i) => handle.insertValue(`phase-2-${i}`))
-      );
-      const survivors = actorHandles.slice(0, 6);
-      const destroyed = actorHandles.slice(6);
-      await Promise.all(destroyed.map((handle) => handle.triggerDestroy()));
-      await Promise.all(survivors.map((handle) => handle.triggerSleep()));
-      await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-      await Promise.all(survivors.map((handle) => handle.ping()));
-      const survivorCounts = await Promise.all(
-        survivors.map((handle) => handle.getCount())
-      );
-      for (const count of survivorCounts) {
-        _vitest.expect.call(void 0, count).toBe(2);
-      }
-      const lifecycleCleanup = /* @__PURE__ */ new Map();
-      for (let i = 0; i < LIFECYCLE_POLL_ATTEMPTS; i++) {
-        let allCleaned = true;
-        for (const actorId of actorIds) {
-          const counts = await observer.getCounts(actorId);
-          lifecycleCleanup.set(actorId, counts.cleanup);
-          if (counts.cleanup < 1) {
-            allCleaned = false;
-          }
-        }
-        if (allCleaned) {
-          break;
-        }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      for (const actorId of actorIds) {
-        _vitest.expect.call(void 0, _nullishCoalesce(lifecycleCleanup.get(actorId), () => ( 0))).toBeGreaterThanOrEqual(1);
-      }
+      const conn = actor.connect();
+      const value = await conn.getValue();
+      _vitest.expect.call(void 0, value).toBe(0);
+      await conn.dispose();
     });
   });
 }
@@ -1750,6 +1868,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) {
@@ -1844,7 +2058,7 @@ function runActorSleepTests(driverTestConfig) {
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1860,7 +2074,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1876,7 +2090,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1892,19 +2106,19 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.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, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.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, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1919,8 +2133,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunkUZV7NXC6cjs.SLEEP_TIMEOUT - 250);
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await sleepActor.setAlarm(_chunkH5TSEPN4cjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -1935,8 +2149,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 200);
+      await sleepActor.setAlarm(_chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -1956,7 +2170,7 @@ function runActorSleepTests(driverTestConfig) {
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       await sleepActor.finishLongRunningRpc();
       await longRunningPromise;
       {
@@ -1965,7 +2179,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -1997,7 +2211,7 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       ws.send(JSON.stringify({ type: "getCounts" }));
       const counts = await new Promise((resolve) => {
         ws.onmessage = (event) => {
@@ -2010,7 +2224,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, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2028,7 +2242,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const fetchDuration = _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250;
+      const fetchDuration = _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
         `long-request?duration=${fetchDuration}`
       );
@@ -2041,7 +2255,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
         _vitest.expect.call(void 0, requestCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2056,13 +2270,13 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.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, _chunkUZV7NXC6cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -2115,6 +2329,7 @@ function runActorDriverTests(driverTestConfig) {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
     runActorSleepTests(driverTestConfig);
+    runActorLifecycleTests(driverTestConfig);
   });
 }
 
@@ -3042,11 +3257,12 @@ function runActorQueueTests(driverTestConfig) {
     _vitest.test.call(void 0, "wait send returns completion response", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.queueActor.getOrCreate(["wait-complete"]);
+      const waitTimeout = driverTestConfig.useRealTimers ? 5e3 : 1e3;
       const actionPromise = handle.receiveAndComplete("tasks");
       const result = await handle.send(
         "tasks",
         { value: 123 },
-        { wait: true, timeout: 1e3 }
+        { wait: true, timeout: waitTimeout }
       );
       await actionPromise;
       _vitest.expect.call(void 0, result).toEqual({
@@ -3189,7 +3405,7 @@ function runActorRunTests(driverTestConfig) {
       const state1 = await actor.getState();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
       const tickCount1 = state1.tickCount;
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.RUN_SLEEP_TIMEOUT + 300);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 300);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.runStarted).toBe(true);
       _vitest.expect.call(void 0, state2.runExited).toBe(false);
@@ -3202,7 +3418,7 @@ function runActorRunTests(driverTestConfig) {
       ]);
       const state = await actor.getState();
       _vitest.expect.call(void 0, state.wakeCount).toBe(1);
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.RUN_SLEEP_TIMEOUT + 300);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 300);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.wakeCount).toBe(2);
     });
@@ -3240,7 +3456,7 @@ function runActorRunTests(driverTestConfig) {
       await waitFor(driverTestConfig, 100);
       const state1 = await actor.getState();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, _chunkUZV7NXC6cjs.RUN_SLEEP_TIMEOUT + 500);
+      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 500);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.wakeCount).toBeGreaterThan(state1.wakeCount);
     });
@@ -3396,8 +3612,14 @@ function runActorWorkflowTests(driverTestConfig) {
       const actor = client.workflowCounterActor.getOrCreate([
         "workflow-basic"
       ]);
-      await waitFor(driverTestConfig, 1e3);
-      const state = await actor.getState();
+      let state = await actor.getState();
+      for (let i = 0; i < 50; i++) {
+        if (state.runCount > 0 && state.history.length > 0 && state.guardTriggered) {
+          break;
+        }
+        await waitFor(driverTestConfig, 100);
+        state = await actor.getState();
+      }
       _vitest.expect.call(void 0, state.runCount).toBeGreaterThan(0);
       _vitest.expect.call(void 0, state.history.length).toBeGreaterThan(0);
       _vitest.expect.call(void 0, state.guardTriggered).toBe(true);
@@ -3405,7 +3627,7 @@ function runActorWorkflowTests(driverTestConfig) {
     _vitest.test.call(void 0, "consumes queue messages via workflow queue.next", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowQueueActor.getOrCreate(["workflow-queue"]);
-      await actor.send(_chunkUZV7NXC6cjs.WORKFLOW_QUEUE_NAME, {
+      await actor.send(_chunkH5TSEPN4cjs.WORKFLOW_QUEUE_NAME, {
         hello: "world"
       });
       await waitFor(driverTestConfig, 200);
@@ -4784,6 +5006,7 @@ function runDriverTests(driverTestConfigPartial) {
             runActorConnTests(driverTestConfig);
             runActorConnStateTests(driverTestConfig);
             runActorConnHibernationTests(driverTestConfig);
+            runConnErrorSerializationTests(driverTestConfig);
             runActorDbTests(driverTestConfig);
             runActorDestroyTests(driverTestConfig);
             runRequestAccessTests(driverTestConfig);
@@ -4838,7 +5061,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 } = _chunkMNS5LY6Mcjs.buildManagerRouter.call(void 0, 
+    const { router } = _chunk3B6PCYJBcjs.buildManagerRouter.call(void 0, 
       parsedConfig,
       managerDriver,
       () => upgradeWebSocket
@@ -4865,7 +5088,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     _invariant2.default.call(void 0, address && typeof address !== "string", "missing server address");
     const port = address.port;
     const serverEndpoint = `http://127.0.0.1:${port}`;
-    _chunkUZV7NXC6cjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
+    _chunkH5TSEPN4cjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
     const cleanup = async () => {
       await new Promise(
         (resolve) => server.close(() => resolve(void 0))