rivetkit 2.1.2 → 2.1.3

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

@@ -4,20 +4,20 @@ import {
   SLEEP_TIMEOUT,
   WORKFLOW_QUEUE_NAME,
   logger
-} from "../chunk-BFI4LYS2.js";
-import "../chunk-YQ5P6KMN.js";
-import "../chunk-TDFDR7AO.js";
-import "../chunk-BSIJG3LG.js";
-import "../chunk-RHUII57M.js";
+} from "../chunk-6T3WSP5M.js";
+import "../chunk-6LHZQSWJ.js";
+import "../chunk-POUBQA6Z.js";
+import "../chunk-YLDDENCZ.js";
+import "../chunk-GNGRMP5E.js";
 import {
   ActorError,
   ClientConfigSchema,
   createClient,
   createClientWithDriver
-} from "../chunk-HB4RGGMC.js";
+} from "../chunk-N7ASEZ2Y.js";
 import {
   importWebSocket
-} from "../chunk-PW3YONDJ.js";
+} from "../chunk-OAOF23ZY.js";
 import "../chunk-KJSYAUOM.js";
 import "../chunk-N4KRDJ56.js";
 import {
@@ -29,14 +29,14 @@ import {
   WS_PROTOCOL_TARGET,
   WS_TEST_PROTOCOL_PATH,
   buildManagerRouter
-} from "../chunk-VMX4I4MP.js";
+} from "../chunk-QUDLEWGD.js";
 import "../chunk-LXUQ667X.js";
 import {
   assertUnreachable
-} from "../chunk-PSUVV4HM.js";
+} from "../chunk-MAXIXG56.js";
 import {
   noopNext
-} from "../chunk-WUXR722E.js";
+} from "../chunk-YET3IZD6.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
@@ -243,10 +243,6 @@ async function setupDriverTest(c, driverTestConfig) {
     vi.setSystemTime(FAKE_TIME);
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
-  c.onTestFinished(() => {
-    logger().info("cleaning up test");
-    cleanup();
-  });
   let client;
   if (driverTestConfig.clientType === "http") {
     client = createClient({
@@ -269,9 +265,13 @@ async function setupDriverTest(c, driverTestConfig) {
   } else {
     assertUnreachable(driverTestConfig.clientType);
   }
-  if (!driverTestConfig.HACK_skipCleanupNet) {
-    c.onTestFinished(async () => await client.dispose());
-  }
+  c.onTestFinished(async () => {
+    if (!driverTestConfig.HACK_skipCleanupNet) {
+      await client.dispose();
+    }
+    logger().info("cleaning up test");
+    await cleanup();
+  });
   return {
     client,
     endpoint
@@ -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,294 +1272,373 @@ 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) {
     describe6(`Actor Database (${variant}) Tests`, () => {
-      test6("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();
-        expect6(count).toBe(0);
-      });
-      test6("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();
-        expect6(values).toHaveLength(2);
-        expect6(values[0].value).toBe("alpha");
-        expect6(values[1].value).toBe("beta");
-        await actor.updateValue(first.id, "alpha-updated");
-        const updated = await actor.getValue(first.id);
-        expect6(updated).toBe("alpha-updated");
-        await actor.deleteValue(second.id);
-        const count = await actor.getCount();
-        expect6(count).toBe(1);
-        const rawCount = await actor.rawSelectCount();
-        expect6(rawCount).toBe(1);
-        const multiValue = await actor.multiStatementInsert("gamma");
-        expect6(multiValue).toBe("gamma-updated");
-      });
-      test6("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");
-        expect6(await actor.getCount()).toBe(1);
-        await actor.transactionRollback("rollback");
-        expect6(await actor.getCount()).toBe(1);
-      });
-      test6("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");
-        expect6(await actor.getCount()).toBe(1);
-        for (let i = 0; i < 3; i++) {
-          await actor.triggerSleep();
-          await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+      test6(
+        "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();
+          expect6(count).toBe(0);
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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();
+          expect6(values.length).toBeGreaterThanOrEqual(2);
+          expect6(values.some((row) => row.value === "alpha")).toBeTruthy();
+          expect6(values.some((row) => row.value === "beta")).toBeTruthy();
+          await actor.updateValue(first.id, "alpha-updated");
+          const updated = await actor.getValue(first.id);
+          expect6(updated).toBe("alpha-updated");
+          await actor.deleteValue(second.id);
+          const count = await actor.getCount();
+          if (driverTestConfig.useRealTimers) {
+            expect6(count).toBeGreaterThanOrEqual(1);
+          } else {
+            expect6(count).toBe(1);
+          }
+          const rawCount = await actor.rawSelectCount();
+          if (driverTestConfig.useRealTimers) {
+            expect6(rawCount).toBeGreaterThanOrEqual(1);
+          } else {
+            expect6(rawCount).toBe(1);
+          }
+          const multiValue = await actor.multiStatementInsert("gamma");
+          expect6(multiValue).toBe("gamma-updated");
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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");
           expect6(await actor.getCount()).toBe(1);
-        }
-      });
-      test6("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);
-        expect6(await actor.getDisconnectInsertCount()).toBe(1);
-      });
-      test6("handles high-volume inserts", async (c) => {
+          await actor.transactionRollback("rollback");
+          expect6(await actor.getCount()).toBe(1);
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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();
+          expect6(baselineCount).toBeGreaterThan(0);
+          for (let i = 0; i < 3; i++) {
+            await actor.triggerSleep();
+            await waitFor(driverTestConfig, SLEEP_WAIT_MS);
+            expect6(await actor.getCount()).toBe(baselineCount);
+          }
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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);
+          expect6(await actor.getDisconnectInsertCount()).toBe(1);
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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) {
+            expect6(count).toBeGreaterThanOrEqual(HIGH_VOLUME_COUNT);
+          } else {
+            expect6(count).toBe(HIGH_VOLUME_COUNT);
+          }
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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);
+            expect6(storedSize).toBe(size);
+          }
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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);
+          expect6(storedSize).toBe(LARGE_PAYLOAD_SIZE);
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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();
+          expect6(grownPages).toBeGreaterThanOrEqual(baselinePages);
+          expect6(shrunkPages).toBeLessThanOrEqual(grownPages);
+          expect6(regrownPages).toBeGreaterThan(shrunkPages);
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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);
+          expect6(result.value).toBe("Updated 49");
+          const value = await actor.getValue(id);
+          expect6(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
+          );
+          expect6(updatedRows).toHaveLength(HOT_ROW_COUNT);
+          for (const row of updatedRows) {
+            expect6(row.value).toMatch(/^v-\d+$/);
+          }
+        },
+        dbTestTimeout
+      );
+      test6(
+        "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
+          );
+          expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          await actor.triggerSleep();
+          await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
+          expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+        },
+        dbTestTimeout
+      );
+    });
+  }
+  describe6("Actor Database Lifecycle Cleanup Tests", () => {
+    test6(
+      "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);
-        expect6(await actor.getCount()).toBe(HIGH_VOLUME_COUNT);
-      });
-      test6("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);
+        }
+        expect6(after.create).toBeGreaterThanOrEqual(before.create);
+        expect6(after.migrate).toBeGreaterThanOrEqual(before.migrate);
+        expect6(after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    test6(
+      "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);
-          expect6(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);
         }
-      });
-      test6("handles large payloads", async (c) => {
+        expect6(cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    test6(
+      "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);
-        expect6(storedSize).toBe(LARGE_PAYLOAD_SIZE);
-      });
-      test6("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 {
+          threw = true;
+        }
+        expect6(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);
+        }
+        expect6(cleanupCount).toBeGreaterThanOrEqual(beforeTotalCleanup + 1);
+      },
+      lifecycleTestTimeout
+    );
+    test6(
+      "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();
-        expect6(grownPages).toBeGreaterThanOrEqual(baselinePages);
-        expect6(shrunkPages).toBeLessThanOrEqual(grownPages);
-        expect6(regrownPages).toBeGreaterThan(shrunkPages);
-      });
-      test6("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);
-        expect6(result.value).toBe("Updated 49");
-        const value = await actor.getValue(id);
-        expect6(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}`))
         );
-        expect6(updatedRows).toHaveLength(HOT_ROW_COUNT);
-        for (const row of updatedRows) {
-          expect6(row.value).toMatch(/^v-\d+$/);
-        }
-      });
-      test6("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}`))
         );
-        expect6((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);
-        expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
-      });
-    });
-  }
-  describe6("Actor Database Lifecycle Cleanup Tests", () => {
-    test6("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 waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      expect6(after.create).toBeGreaterThanOrEqual(before.create);
-      expect6(after.migrate).toBeGreaterThanOrEqual(before.migrate);
-      expect6(after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
-    });
-    test6("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;
-        }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      expect6(cleanupCount).toBeGreaterThanOrEqual(before.cleanup + 1);
-    });
-    test6("runs db provider cleanup when migration fails", 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;
-      try {
-        await lifecycle.ping();
-      } catch {
-        threw = true;
-      }
-      expect6(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 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) {
+            expect6(count).toBeGreaterThanOrEqual(2);
+          } else {
+            expect6(count).toBe(2);
+          }
         }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      expect6(cleanupCount).toBeGreaterThanOrEqual(1);
-    });
-    test6("handles parallel actor lifecycle churn", 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 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) {
-        expect6(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;
+        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);
         }
-        if (allCleaned) {
-          break;
+        for (const actorId of actorIds) {
+          expect6(lifecycleCleanup.get(actorId) ?? 0).toBeGreaterThanOrEqual(1);
         }
-        await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
-      }
-      for (const actorId of actorIds) {
-        expect6(lifecycleCleanup.get(actorId) ?? 0).toBeGreaterThanOrEqual(1);
-      }
-    });
+      },
+      lifecycleTestTimeout
+    );
   });
 }
 
@@ -3042,11 +3122,12 @@ function runActorQueueTests(driverTestConfig) {
     test18("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;
       expect18(result).toEqual({
@@ -3396,8 +3477,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();
+      }
       expect22(state.runCount).toBeGreaterThan(0);
       expect22(state.history.length).toBeGreaterThan(0);
       expect22(state.guardTriggered).toBe(true);