rivetkit 2.1.5 → 2.1.6-rc.1

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

@@ -1,25 +1,34 @@
 import {
   HIBERNATION_SLEEP_TIMEOUT,
+  MANY_QUEUE_NAMES,
   RUN_SLEEP_TIMEOUT,
   SLEEP_TIMEOUT,
+  WORKFLOW_NESTED_QUEUE_NAME,
   WORKFLOW_QUEUE_NAME,
   logger
-} from "../chunk-R5OQUSLN.js";
-import "../chunk-WY2SHWXQ.js";
-import "../chunk-S662Y6ZU.js";
-import "../chunk-ZPWOYQHN.js";
-import "../chunk-SRIM3GHD.js";
+} from "../chunk-DK46YYCJ.js";
+import "../chunk-SVHJSM2E.js";
+import "../chunk-JJSPHLJN.js";
+import "../chunk-UQZRMTM3.js";
+import "../chunk-EGWXXBZV.js";
+import "../chunk-YGYGANCA.js";
+import "../chunk-EONWXYMN.js";
+import {
+  createClient
+} from "../chunk-T5KYKM6R.js";
 import {
   ActorError,
   ClientConfigSchema,
-  createClient,
   createClientWithDriver
-} from "../chunk-JPXO2H55.js";
+} from "../chunk-WW27B6DM.js";
 import {
   importWebSocket
-} from "../chunk-2OK7S6QF.js";
-import "../chunk-KJSYAUOM.js";
-import "../chunk-N4KRDJ56.js";
+} from "../chunk-I5I6OALK.js";
+import "../chunk-MLK3GY6P.js";
+import "../chunk-GFGRBYO2.js";
+import {
+  buildManagerRouter
+} from "../chunk-C4EB42ET.js";
 import {
   HEADER_ACTOR_ID,
   WS_PROTOCOL_ACTOR,
@@ -27,27 +36,26 @@ import {
   WS_PROTOCOL_ENCODING,
   WS_PROTOCOL_STANDARD,
   WS_PROTOCOL_TARGET,
-  WS_TEST_PROTOCOL_PATH,
-  buildManagerRouter
-} from "../chunk-MIX2KB6U.js";
+  WS_TEST_PROTOCOL_PATH
+} from "../chunk-PQWI44WD.js";
 import "../chunk-LXUQ667X.js";
 import {
   assertUnreachable
-} from "../chunk-TADUYCHF.js";
+} from "../chunk-C22JYHVT.js";
 import {
   noopNext
-} from "../chunk-EIATSBYZ.js";
+} from "../chunk-VWYO36X4.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-7HTNH26M.js";
+} from "../chunk-AKUJ5OTO.js";
 import "../chunk-424PT5DM.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket } from "@hono/node-ws";
 import invariant2 from "invariant";
-import { describe as describe31 } from "vitest";
+import { describe as describe33 } from "vitest";
 
 // src/driver-test-suite/tests/action-features.ts
 import { describe, expect, test } from "vitest";
@@ -372,19 +380,27 @@ function runActionFeaturesTests(driverTestConfig) {
         const instance = client.largePayloadActor.getOrCreate();
         const items = [];
         for (let i = 0; i < 800; i++) {
-          items.push(`Item ${i} with some additional text to increase size`);
+          items.push(
+            `Item ${i} with some additional text to increase size`
+          );
         }
         const result = await instance.processLargeRequest({ items });
         expect(result.itemCount).toBe(800);
-        expect(result.firstItem).toBe("Item 0 with some additional text to increase size");
-        expect(result.lastItem).toBe("Item 799 with some additional text to increase size");
+        expect(result.firstItem).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        expect(result.lastItem).toBe(
+          "Item 799 with some additional text to increase size"
+        );
       });
       test("should reject request exceeding maxIncomingMessageSize", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.largePayloadActor.getOrCreate();
         const items = [];
         for (let i = 0; i < 1500; i++) {
-          items.push(`Item ${i} with some additional text to increase size`);
+          items.push(
+            `Item ${i} with some additional text to increase size`
+          );
         }
         await expect(
           instance.processLargeRequest({ items })
@@ -395,8 +411,12 @@ function runActionFeaturesTests(driverTestConfig) {
         const instance = client.largePayloadActor.getOrCreate();
         const result = await instance.getLargeResponse(800);
         expect(result.items).toHaveLength(800);
-        expect(result.items[0]).toBe("Item 0 with some additional text to increase size");
-        expect(result.items[799]).toBe("Item 799 with some additional text to increase size");
+        expect(result.items[0]).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        expect(result.items[799]).toBe(
+          "Item 799 with some additional text to increase size"
+        );
       });
       test("should reject response exceeding maxOutgoingMessageSize", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -421,7 +441,9 @@ function runAccessControlTests(driverTestConfig) {
     });
     test2("passes connection id into canPublish context", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.accessControlActor.getOrCreate(["publish-ctx"]);
+      const handle = client.accessControlActor.getOrCreate([
+        "publish-ctx"
+      ]);
       await handle.send("allowedQueue", { value: "one" });
       const connId = await handle.allowedGetLastCanPublishConnId();
       expect2(typeof connId).toBe("string");
@@ -512,16 +534,21 @@ function runAccessControlTests(driverTestConfig) {
         "undefined-event"
       ]);
       const conn = handle.connect();
-      const eventPromise = new Promise((resolve, reject) => {
-        const unsubscribeError = conn.onError((error) => {
-          reject(error);
-        });
-        const unsubscribeEvent = conn.on("undefinedEvent", (payload) => {
-          unsubscribeError();
-          unsubscribeEvent();
-          resolve(payload);
-        });
-      });
+      const eventPromise = new Promise(
+        (resolve, reject) => {
+          const unsubscribeError = conn.onError((error) => {
+            reject(error);
+          });
+          const unsubscribeEvent = conn.on(
+            "undefinedEvent",
+            (payload) => {
+              unsubscribeError();
+              unsubscribeEvent();
+              resolve(payload);
+            }
+          );
+        }
+      );
       await conn.allowedAction("undefined-subscribe-ready");
       await conn.allowedBroadcastUndefinedEvent("wildcard");
       expect2(await eventPromise).toEqual({ value: "wildcard" });
@@ -745,6 +772,65 @@ function runActorConnTests(driverTestConfig) {
         await conn1.dispose();
         await conn2.dispose();
       });
+      test3("should call getParams for each connection", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        let connectionCount = 0;
+        const handle = client.counterWithParams.getOrCreate(
+          ["test-get-params"],
+          {
+            getParams: async () => ({
+              name: `user${++connectionCount}`
+            })
+          }
+        );
+        const conn1 = handle.connect();
+        await conn1.getInitializers();
+        await conn1.dispose();
+        const conn2 = handle.connect();
+        const initializers = await conn2.getInitializers();
+        expect3(initializers).toEqual(["user1", "user2"]);
+        expect3(connectionCount).toBe(2);
+        await conn2.dispose();
+      });
+      test3("should surface getParams errors and retry connection setup", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        let attempts = 0;
+        const handle = client.counterWithParams.getOrCreate(
+          ["test-get-params-retry"],
+          {
+            getParams: async () => {
+              attempts++;
+              if (attempts === 1) {
+                throw new Error("token unavailable");
+              }
+              return { name: "user1" };
+            }
+          }
+        );
+        const conn = handle.connect();
+        const receivedErrors = [];
+        conn.onError((error) => {
+          receivedErrors.push({
+            group: error.group,
+            code: error.code
+          });
+        });
+        await expect3(conn.getInitializers()).rejects.toMatchObject({
+          group: "client",
+          code: "get_params_failed"
+        });
+        await vi2.waitFor(
+          async () => {
+            expect3(await conn.getInitializers()).toEqual(["user1"]);
+          },
+          { timeout: 1e4 }
+        );
+        expect3(receivedErrors).toEqual([
+          { group: "client", code: "get_params_failed" }
+        ]);
+        expect3(attempts).toBeGreaterThanOrEqual(2);
+        await conn.dispose();
+      });
     });
     describe3("Lifecycle Hooks", () => {
       test3("should trigger lifecycle hooks", async (c) => {
@@ -922,12 +1008,18 @@ function runActorConnTests(driverTestConfig) {
         const connection = handle.connect();
         const items = [];
         for (let i = 0; i < 800; i++) {
-          items.push(`Item ${i} with some additional text to increase size`);
+          items.push(
+            `Item ${i} with some additional text to increase size`
+          );
         }
         const result = await connection.processLargeRequest({ items });
         expect3(result.itemCount).toBe(800);
-        expect3(result.firstItem).toBe("Item 0 with some additional text to increase size");
-        expect3(result.lastItem).toBe("Item 799 with some additional text to increase size");
+        expect3(result.firstItem).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        expect3(result.lastItem).toBe(
+          "Item 799 with some additional text to increase size"
+        );
         const lastRequestSize = await connection.getLastRequestSize();
         expect3(lastRequestSize).toBe(800);
         await connection.dispose();
@@ -940,7 +1032,9 @@ function runActorConnTests(driverTestConfig) {
         const connection = handle.connect();
         const items = [];
         for (let i = 0; i < 1500; i++) {
-          items.push(`Item ${i} with some additional text to increase size`);
+          items.push(
+            `Item ${i} with some additional text to increase size`
+          );
         }
         await expect3(
           connection.processLargeRequest({ items })
@@ -955,8 +1049,12 @@ function runActorConnTests(driverTestConfig) {
         const connection = handle.connect();
         const result = await connection.getLargeResponse(800);
         expect3(result.items).toHaveLength(800);
-        expect3(result.items[0]).toBe("Item 0 with some additional text to increase size");
-        expect3(result.items[799]).toBe("Item 799 with some additional text to increase size");
+        expect3(result.items[0]).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        expect3(result.items[799]).toBe(
+          "Item 799 with some additional text to increase size"
+        );
         await connection.dispose();
       });
       test3("should reject response exceeding maxOutgoingMessageSize", async (c) => {
@@ -1279,7 +1377,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "bootstraps schema on startup",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-bootstrap-${crypto.randomUUID()}`
           ]);
@@ -1291,7 +1392,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "supports CRUD, raw SQL, and multi-statement exec",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-crud-${crypto.randomUUID()}`
           ]);
@@ -1300,8 +1404,12 @@ function runActorDbTests(driverTestConfig) {
           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();
+          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");
@@ -1326,7 +1434,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "handles transactions",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-tx-${crypto.randomUUID()}`
           ]);
@@ -1341,7 +1452,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "persists across sleep and wake cycles",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-sleep-${crypto.randomUUID()}`
           ]);
@@ -1360,9 +1474,14 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "completes onDisconnect DB writes before sleeping",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const key = `db-${variant}-disconnect-${crypto.randomUUID()}`;
-          const actor = getDbActor(client, variant).getOrCreate([key]);
+          const actor = getDbActor(client, variant).getOrCreate([
+            key
+          ]);
           await actor.reset();
           await actor.configureDisconnectInsert(true, 250);
           await waitFor(driverTestConfig, SLEEP_WAIT_MS + 250);
@@ -1374,7 +1493,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "handles high-volume inserts",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-high-volume-${crypto.randomUUID()}`
           ]);
@@ -1392,7 +1514,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "handles payloads across chunk boundaries",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-chunk-${crypto.randomUUID()}`
           ]);
@@ -1408,7 +1533,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "handles large payloads",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-large-${crypto.randomUUID()}`
           ]);
@@ -1422,7 +1550,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "supports shrink and regrow workloads with vacuum",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-shrink-regrow-${crypto.randomUUID()}`
           ]);
@@ -1451,7 +1582,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "handles repeated updates to the same row",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-updates-${crypto.randomUUID()}`
           ]);
@@ -1480,7 +1614,10 @@ function runActorDbTests(driverTestConfig) {
       test6(
         "passes integrity checks after mixed workload and sleep",
         async (c) => {
-          const { client } = await setupDriverTest(c, driverTestConfig);
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
           const actor = getDbActor(client, variant).getOrCreate([
             `db-${variant}-integrity-${crypto.randomUUID()}`
           ]);
@@ -1489,10 +1626,14 @@ function runActorDbTests(driverTestConfig) {
             INTEGRITY_SEED_COUNT,
             INTEGRITY_CHURN_COUNT
           );
-          expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          expect6((await actor.integrityCheck()).toLowerCase()).toBe(
+            "ok"
+          );
           await actor.triggerSleep();
           await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-          expect6((await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          expect6((await actor.integrityCheck()).toLowerCase()).toBe(
+            "ok"
+          );
         },
         dbTestTimeout
       );
@@ -1503,7 +1644,9 @@ function runActorDbTests(driverTestConfig) {
       "runs db provider cleanup on sleep",
       async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const observer = client.dbLifecycleObserver.getOrCreate([
+          "observer"
+        ]);
         const lifecycle = client.dbLifecycle.getOrCreate([
           `db-lifecycle-sleep-${crypto.randomUUID()}`
         ]);
@@ -1523,7 +1666,9 @@ function runActorDbTests(driverTestConfig) {
         }
         expect6(after.create).toBeGreaterThanOrEqual(before.create);
         expect6(after.migrate).toBeGreaterThanOrEqual(before.migrate);
-        expect6(after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+        expect6(after.cleanup).toBeGreaterThanOrEqual(
+          before.cleanup + 1
+        );
       },
       lifecycleTestTimeout
     );
@@ -1531,7 +1676,9 @@ function runActorDbTests(driverTestConfig) {
       "runs db provider cleanup on destroy",
       async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const observer = client.dbLifecycleObserver.getOrCreate([
+          "observer"
+        ]);
         const lifecycle = client.dbLifecycle.getOrCreate([
           `db-lifecycle-destroy-${crypto.randomUUID()}`
         ]);
@@ -1557,7 +1704,9 @@ function runActorDbTests(driverTestConfig) {
       "runs db provider cleanup when migration fails",
       async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        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]);
@@ -1576,7 +1725,9 @@ function runActorDbTests(driverTestConfig) {
           }
           await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
         }
-        expect6(cleanupCount).toBeGreaterThanOrEqual(beforeTotalCleanup + 1);
+        expect6(cleanupCount).toBeGreaterThanOrEqual(
+          beforeTotalCleanup + 1
+        );
       },
       lifecycleTestTimeout
     );
@@ -1584,7 +1735,9 @@ function runActorDbTests(driverTestConfig) {
       "handles parallel actor lifecycle churn",
       async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const observer = client.dbLifecycleObserver.getOrCreate(["observer"]);
+        const observer = client.dbLifecycleObserver.getOrCreate([
+          "observer"
+        ]);
         const actorHandles = Array.from(
           { length: 12 },
           (_, i) => client.dbLifecycle.getOrCreate([
@@ -1595,17 +1748,27 @@ function runActorDbTests(driverTestConfig) {
           actorHandles.map((handle) => handle.getActorId())
         );
         await Promise.all(
-          actorHandles.map((handle, i) => handle.insertValue(`phase-1-${i}`))
+          actorHandles.map(
+            (handle, i) => handle.insertValue(`phase-1-${i}`)
+          )
+        );
+        await Promise.all(
+          actorHandles.map((handle) => handle.triggerSleep())
         );
-        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}`))
+          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 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(
@@ -1634,7 +1797,9 @@ function runActorDbTests(driverTestConfig) {
           await waitFor(driverTestConfig, LIFECYCLE_POLL_INTERVAL_MS);
         }
         for (const actorId of actorIds) {
-          expect6(lifecycleCleanup.get(actorId) ?? 0).toBeGreaterThanOrEqual(1);
+          expect6(
+            lifecycleCleanup.get(actorId) ?? 0
+          ).toBeGreaterThanOrEqual(1);
         }
       },
       lifecycleTestTimeout
@@ -1896,9 +2061,7 @@ function runActorLifecycleTests(driverTestConfig) {
       const actorKey = `test-stop-before-instantiation-${Date.now()}`;
       const actors = Array.from(
         { length: 5 },
-        (_, i) => client.startStopRaceActor.getOrCreate([
-          `${actorKey}-${i}`
-        ])
+        (_, i) => client.startStopRaceActor.getOrCreate([`${actorKey}-${i}`])
       );
       const ids = await Promise.all(actors.map((a) => a.resolve()));
       await Promise.all(actors.map((a) => a.destroy()));
@@ -1911,9 +2074,7 @@ function runActorLifecycleTests(driverTestConfig) {
           expect9(err.group).toBe("actor");
           expect9(err.code).toBe("not_found");
         }
-        expect9(destroyed, `actor ${id} should be destroyed`).toBe(
-          true
-        );
+        expect9(destroyed, `actor ${id} should be destroyed`).toBe(true);
       }
     });
     test9("onBeforeActorStart completes before stop proceeds", async (c) => {
@@ -1930,9 +2091,7 @@ function runActorLifecycleTests(driverTestConfig) {
       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 actor = client.startStopRaceActor.getOrCreate([actorKey]);
         const resolvePromise = actor.resolve();
         const destroyPromise = actor.destroy();
         await Promise.all([resolvePromise, destroyPromise]);
@@ -1945,9 +2104,7 @@ function runActorLifecycleTests(driverTestConfig) {
       const actor = client.startStopRaceActor.getOrCreate([actorKey]);
       const id = await actor.resolve();
       await actor.destroy();
-      const newActor = client.startStopRaceActor.getOrCreate([
-        actorKey
-      ]);
+      const newActor = client.startStopRaceActor.getOrCreate([actorKey]);
       const result = await newActor.ping();
       expect9(result).toBe("pong");
       await newActor.destroy();
@@ -2014,10 +2171,7 @@ function runActorScheduleTests(driverTestConfig) {
           expect10(history1[0]).toBe("first");
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          expect10(history2.slice(0, 2)).toEqual([
-            "first",
-            "second"
-          ]);
+          expect10(history2.slice(0, 2)).toEqual(["first", "second"]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
           expect10(history3).toEqual(["first", "second", "third"]);
@@ -2098,6 +2252,28 @@ function runActorSleepTests(driverTestConfig) {
         expect11(startCount).toBe(2);
       }
     });
+    test11("waitUntil can broadcast before sleep disconnect", async (c) => {
+      var _a2;
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithWaitUntilMessage.getOrCreate().connect();
+      const receivedMessages = [];
+      sleepActor.once("sleeping", (message) => {
+        receivedMessages.push(message);
+      });
+      await sleepActor.triggerSleep();
+      await waitFor(driverTestConfig, 250);
+      expect11(receivedMessages).toHaveLength(1);
+      expect11((_a2 = receivedMessages[0]) == null ? void 0 : _a2.startCount).toBe(1);
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, 250);
+      const sleepActor2 = client.sleepWithWaitUntilMessage.getOrCreate();
+      {
+        const { startCount, sleepCount, waitUntilMessageCount } = await sleepActor2.getCounts();
+        expect11(waitUntilMessageCount).toBe(1);
+        expect11(sleepCount).toBe(1);
+        expect11(startCount).toBe(2);
+      }
+    });
     test11("rpc calls keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
@@ -2283,6 +2459,64 @@ function runActorSleepTests(driverTestConfig) {
         expect11(startCount).toBe(1);
       }
     });
+    test11("preventSleep blocks auto sleep until cleared", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(0);
+        expect11(status.startCount).toBe(1);
+        expect11(status.preventSleep).toBe(false);
+        expect11(status.preventSleepOnWake).toBe(false);
+      }
+      expect11(await sleepActor.setPreventSleep(true)).toBe(true);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(0);
+        expect11(status.startCount).toBe(1);
+        expect11(status.preventSleep).toBe(true);
+      }
+      expect11(await sleepActor.setPreventSleep(false)).toBe(false);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(1);
+        expect11(status.startCount).toBe(2);
+        expect11(status.preventSleep).toBe(false);
+      }
+    });
+    test11("preventSleep can be restored during onWake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+      expect11(await sleepActor.setPreventSleepOnWake(true)).toBe(true);
+      await sleepActor.triggerSleep();
+      await waitFor(driverTestConfig, 250);
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(1);
+        expect11(status.startCount).toBe(2);
+        expect11(status.preventSleep).toBe(true);
+        expect11(status.preventSleepOnWake).toBe(true);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(1);
+        expect11(status.startCount).toBe(2);
+        expect11(status.preventSleep).toBe(true);
+      }
+      expect11(await sleepActor.setPreventSleepOnWake(false)).toBe(false);
+      expect11(await sleepActor.setPreventSleep(false)).toBe(false);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        expect11(status.sleepCount).toBe(2);
+        expect11(status.startCount).toBe(3);
+        expect11(status.preventSleep).toBe(false);
+        expect11(status.preventSleepOnWake).toBe(false);
+      }
+    });
   });
 }
 
@@ -2745,26 +2979,24 @@ function runActorInspectorTests(driverTestConfig) {
       });
       expect16(response.status).toBe(200);
       const data = await response.json();
-      expect16(data).toEqual({ state: { count: 5 } });
+      expect16(data).toEqual({
+        state: { count: 5 },
+        isStateEnabled: true
+      });
     });
     test16("PATCH /inspector/state updates actor state", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-set-state"
-      ]);
+      const handle = client.counter.getOrCreate(["inspector-set-state"]);
       await handle.increment(5);
       const gatewayUrl = await handle.getGatewayUrl();
-      const patchResponse = await fetch(
-        `${gatewayUrl}/inspector/state`,
-        {
-          method: "PATCH",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: "Bearer token"
-          },
-          body: JSON.stringify({ state: { count: 42 } })
-        }
-      );
+      const patchResponse = await fetch(`${gatewayUrl}/inspector/state`, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer token"
+        },
+        body: JSON.stringify({ state: { count: 42 } })
+      });
       expect16(patchResponse.status).toBe(200);
       const patchData = await patchResponse.json();
       expect16(patchData).toEqual({ ok: true });
@@ -2806,9 +3038,7 @@ function runActorInspectorTests(driverTestConfig) {
     });
     test16("POST /inspector/action/:name executes an action", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-action"
-      ]);
+      const handle = client.counter.getOrCreate(["inspector-action"]);
       await handle.increment(10);
       const gatewayUrl = await handle.getGatewayUrl();
       const response = await fetch(
@@ -2852,9 +3082,7 @@ function runActorInspectorTests(driverTestConfig) {
     });
     test16("GET /inspector/traces returns trace data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-traces"
-      ]);
+      const handle = client.counter.getOrCreate(["inspector-traces"]);
       await handle.increment(1);
       const gatewayUrl = await handle.getGatewayUrl();
       const response = await fetch(
@@ -2871,9 +3099,7 @@ function runActorInspectorTests(driverTestConfig) {
     });
     test16("GET /inspector/workflow-history returns workflow status", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-workflow"
-      ]);
+      const handle = client.counter.getOrCreate(["inspector-workflow"]);
       await handle.increment(0);
       const gatewayUrl = await handle.getGatewayUrl();
       const response = await fetch(
@@ -2889,21 +3115,97 @@ function runActorInspectorTests(driverTestConfig) {
       expect16(data.isWorkflowEnabled).toBe(false);
       expect16(data.history).toBeNull();
     });
-    test16("GET /inspector/summary returns full actor snapshot", async (c) => {
+    test16("GET /inspector/database/schema returns SQLite schema", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-summary"
+      const handle = client.dbActorRaw.getOrCreate([
+        `inspector-database-schema-${crypto.randomUUID()}`
       ]);
-      await handle.increment(7);
+      await handle.insertValue("Alice");
+      await handle.insertValue("Bob");
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/database/schema`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      expect16(response.status).toBe(200);
+      const data = await response.json();
+      expect16(Array.isArray(data.schema.tables)).toBe(true);
+      const testDataTable = data.schema.tables.find(
+        (table) => table.table.name === "test_data"
+      );
+      expect16(testDataTable).toBeDefined();
+      expect16(testDataTable == null ? void 0 : testDataTable.table.schema).toBe("main");
+      expect16(testDataTable == null ? void 0 : testDataTable.table.type).toBe("table");
+      expect16(testDataTable == null ? void 0 : testDataTable.records).toBe(2);
+      expect16(testDataTable == null ? void 0 : testDataTable.columns.map((column) => column.name)).toEqual(
+        ["id", "value", "payload", "created_at"]
+      );
+    });
+    test16("GET /inspector/workflow-history returns populated history for active workflows", async (c) => {
+      var _a, _b, _c;
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.workflowCounterActor.getOrCreate([
+        "inspector-workflow-active"
+      ]);
+      let state = await handle.getState();
+      for (let i = 0; i < 40 && (state.runCount === 0 || state.history.length === 0); i++) {
+        await waitFor(driverTestConfig, 50);
+        state = await handle.getState();
+      }
+      expect16(state.runCount).toBeGreaterThan(0);
+      expect16(state.history.length).toBeGreaterThan(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/workflow-history`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      expect16(response.status).toBe(200);
+      const data = await response.json();
+      expect16(data.isWorkflowEnabled).toBe(true);
+      expect16(data.history).not.toBeNull();
+      expect16((_a = data.history) == null ? void 0 : _a.nameRegistry.length).toBeGreaterThan(0);
+      expect16((_b = data.history) == null ? void 0 : _b.entries.length).toBeGreaterThan(0);
+      expect16(
+        Object.keys(((_c = data.history) == null ? void 0 : _c.entryMetadata) ?? {}).length
+      ).toBeGreaterThan(0);
+    });
+    test16("GET /inspector/database/rows returns SQLite rows", async (c) => {
+      var _a, _b, _c, _d;
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.dbActorRaw.getOrCreate([
+        `inspector-database-rows-${crypto.randomUUID()}`
+      ]);
+      await handle.insertValue("Alice");
+      await handle.insertValue("Bob");
       const gatewayUrl = await handle.getGatewayUrl();
       const response = await fetch(
-        `${gatewayUrl}/inspector/summary`,
+        `${gatewayUrl}/inspector/database/rows?table=test_data&limit=1&offset=1`,
         {
           headers: { Authorization: "Bearer token" }
         }
       );
       expect16(response.status).toBe(200);
       const data = await response.json();
+      expect16(data.rows).toHaveLength(1);
+      expect16((_a = data.rows[0]) == null ? void 0 : _a.id).toBe(2);
+      expect16((_b = data.rows[0]) == null ? void 0 : _b.value).toBe("Bob");
+      expect16((_c = data.rows[0]) == null ? void 0 : _c.payload).toBe("");
+      expect16(typeof ((_d = data.rows[0]) == null ? void 0 : _d.created_at)).toBe("number");
+    });
+    test16("GET /inspector/summary returns full actor snapshot", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate(["inspector-summary"]);
+      await handle.increment(7);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(`${gatewayUrl}/inspector/summary`, {
+        headers: { Authorization: "Bearer token" }
+      });
+      expect16(response.status).toBe(200);
+      const data = await response.json();
       expect16(data.state).toEqual({ count: 7 });
       expect16(Array.isArray(data.connections)).toBe(true);
       expect16(data.rpcs).toContain("increment");
@@ -2913,11 +3215,34 @@ function runActorInspectorTests(driverTestConfig) {
       expect16(data.isWorkflowEnabled).toBe(false);
       expect16(data.workflowHistory).toBeNull();
     });
-    test16("inspector endpoints require auth in non-dev mode", async (c) => {
+    test16("GET /inspector/summary returns populated workflow history for active workflows", async (c) => {
+      var _a, _b, _c;
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counter.getOrCreate([
-        "inspector-auth"
+      const handle = client.workflowCounterActor.getOrCreate([
+        "inspector-summary-workflow"
       ]);
+      let state = await handle.getState();
+      for (let i = 0; i < 40 && (state.runCount === 0 || state.history.length === 0); i++) {
+        await waitFor(driverTestConfig, 50);
+        state = await handle.getState();
+      }
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(`${gatewayUrl}/inspector/summary`, {
+        headers: { Authorization: "Bearer token" }
+      });
+      expect16(response.status).toBe(200);
+      const data = await response.json();
+      expect16(data.isWorkflowEnabled).toBe(true);
+      expect16(data.workflowHistory).not.toBeNull();
+      expect16((_a = data.workflowHistory) == null ? void 0 : _a.nameRegistry.length).toBeGreaterThan(0);
+      expect16((_b = data.workflowHistory) == null ? void 0 : _b.entries.length).toBeGreaterThan(0);
+      expect16(
+        Object.keys(((_c = data.workflowHistory) == null ? void 0 : _c.entryMetadata) ?? {}).length
+      ).toBeGreaterThan(0);
+    });
+    test16("inspector endpoints require auth in non-dev mode", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.counter.getOrCreate(["inspector-auth"]);
       await handle.increment(0);
       const gatewayUrl = await handle.getGatewayUrl();
       const response = await fetch(`${gatewayUrl}/inspector/state`, {
@@ -2938,7 +3263,9 @@ function runActorKvTests(driverTestConfig) {
         driverTestConfig
       );
       const client = rawClient;
-      const kvHandle = client.kvActor.getOrCreate(["kv-text"]);
+      const kvHandle = client.kvActor.getOrCreate([
+        "kv-text"
+      ]);
       await kvHandle.putText("greeting", "hello");
       const value = await kvHandle.getText("greeting");
       expect17(value).toBe("hello");
@@ -2951,46 +3278,72 @@ function runActorKvTests(driverTestConfig) {
         { key: "prefix-b", value: "beta" }
       ]);
     });
-    test17(
-      "supports arrayBuffer encoding and decoding",
-      async (c) => {
-        const { client: rawClient } = await setupDriverTest(
-          c,
-          driverTestConfig
-        );
-        const client = rawClient;
-        const kvHandle = client.kvActor.getOrCreate([
-          "kv-array-buffer"
-        ]);
-        const values = await kvHandle.roundtripArrayBuffer("bytes", [
-          4,
-          8,
-          15,
-          16,
-          23,
-          42
-        ]);
-        expect17(values).toEqual([4, 8, 15, 16, 23, 42]);
-      }
-    );
-  });
-}
-
-// src/driver-test-suite/tests/actor-metadata.ts
-import { describe as describe19, expect as expect18, test as test18 } from "vitest";
-function runActorMetadataTests(driverTestConfig) {
-  describe19("Actor Metadata Tests", () => {
-    describe19("Actor Name", () => {
-      test18("should provide access to actor name", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.metadataActor.getOrCreate();
-        const actorName = await handle.getActorName();
-        expect18(actorName).toBe("metadataActor");
-      });
-      test18("should preserve actor name in state during onWake", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.metadataActor.getOrCreate();
-        const storedName = await handle.getStoredActorName();
+    test17("supports range scans and range deletes", async (c) => {
+      const { client: rawClient } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
+      const client = rawClient;
+      const kvHandle = client.kvActor.getOrCreate([
+        "kv-range"
+      ]);
+      await kvHandle.putText("a", "alpha");
+      await kvHandle.putText("b", "bravo");
+      await kvHandle.putText("c", "charlie");
+      await kvHandle.putText("d", "delta");
+      const range = await kvHandle.listTextRange("b", "d");
+      expect17(range).toEqual([
+        { key: "b", value: "bravo" },
+        { key: "c", value: "charlie" }
+      ]);
+      const reversed = await kvHandle.listTextRange("a", "d", {
+        reverse: true,
+        limit: 2
+      });
+      expect17(reversed).toEqual([
+        { key: "c", value: "charlie" },
+        { key: "b", value: "bravo" }
+      ]);
+      await kvHandle.deleteTextRange("b", "d");
+      const remaining = await kvHandle.listText("");
+      expect17(remaining).toEqual([
+        { key: "a", value: "alpha" },
+        { key: "d", value: "delta" }
+      ]);
+    });
+    test17("supports arrayBuffer encoding and decoding", async (c) => {
+      const { client: rawClient } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
+      const client = rawClient;
+      const kvHandle = client.kvActor.getOrCreate([
+        "kv-array-buffer"
+      ]);
+      const values = await kvHandle.roundtripArrayBuffer(
+        "bytes",
+        [4, 8, 15, 16, 23, 42]
+      );
+      expect17(values).toEqual([4, 8, 15, 16, 23, 42]);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-metadata.ts
+import { describe as describe19, expect as expect18, test as test18 } from "vitest";
+function runActorMetadataTests(driverTestConfig) {
+  describe19("Actor Metadata Tests", () => {
+    describe19("Actor Name", () => {
+      test18("should provide access to actor name", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const actorName = await handle.getActorName();
+        expect18(actorName).toBe("metadataActor");
+      });
+      test18("should preserve actor name in state during onWake", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const storedName = await handle.getStoredActorName();
         expect18(storedName).toBe("metadataActor");
       });
     });
@@ -3110,6 +3463,49 @@ function runActorOnStateChangeTests(driverTestConfig) {
 import { describe as describe21, expect as expect20, test as test20 } from "vitest";
 function runActorQueueTests(driverTestConfig) {
   describe21("Actor Queue Tests", () => {
+    async function expectManyQueueChildToDrain(handle, key) {
+      const child = handle.getOrCreate([key]);
+      const conn = child.connect();
+      const messageCount = MANY_QUEUE_NAMES.length * 4;
+      try {
+        expect20(await conn.ping()).toEqual(
+          expect20.objectContaining({
+            pong: true
+          })
+        );
+        await Promise.all(
+          Array.from(
+            { length: messageCount },
+            (_, index) => child.send(
+              MANY_QUEUE_NAMES[index % MANY_QUEUE_NAMES.length],
+              { index }
+            )
+          )
+        );
+        let snapshot = await child.getSnapshot();
+        for (let i = 0; i < 60 && snapshot.processed.length < messageCount; i++) {
+          await waitFor(driverTestConfig, 100);
+          snapshot = await child.getSnapshot();
+        }
+        expect20(snapshot.started).toBe(true);
+        expect20(snapshot.processed).toHaveLength(messageCount);
+        expect20(new Set(snapshot.processed)).toEqual(
+          new Set(MANY_QUEUE_NAMES)
+        );
+        expect20(
+          await child.send(
+            MANY_QUEUE_NAMES[0],
+            { index: messageCount },
+            { wait: true, timeout: 1e3 }
+          )
+        ).toEqual({
+          status: "completed",
+          response: { ok: true, index: messageCount }
+        });
+      } finally {
+        await conn.dispose().catch(() => void 0);
+      }
+    }
     test20("client can send to actor queue", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.queueActor.getOrCreate(["client-send"]);
@@ -3282,6 +3678,44 @@ function runActorQueueTests(driverTestConfig) {
       const result = await resultPromise;
       expect20(result.status).toBe("timedOut");
     });
+    test20(
+      "drains many-queue child actors created from actions while connected",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const parent = client.manyQueueActionParentActor.getOrCreate([
+          "many-action-parent"
+        ]);
+        expect20(await parent.spawnChild("many-action-child")).toEqual({
+          key: "many-action-child"
+        });
+        await expectManyQueueChildToDrain(
+          client.manyQueueChildActor,
+          "many-action-child"
+        );
+      }
+    );
+    test20(
+      "drains many-queue child actors created from run handlers while connected",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const parent = client.manyQueueRunParentActor.getOrCreate([
+          "many-run-parent"
+        ]);
+        expect20(await parent.queueSpawn("many-run-child")).toEqual({
+          queued: true
+        });
+        let spawned = await parent.getSpawned();
+        for (let i = 0; i < 30 && !spawned.includes("many-run-child"); i++) {
+          await waitFor(driverTestConfig, 100);
+          spawned = await parent.getSpawned();
+        }
+        expect20(spawned).toContain("many-run-child");
+        await expectManyQueueChildToDrain(
+          client.manyQueueChildActor,
+          "many-run-child"
+        );
+      }
+    );
     test20("manual receive retries message when not completed", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.queueActor.getOrCreate([
@@ -3290,7 +3724,9 @@ function runActorQueueTests(driverTestConfig) {
       await handle.send("tasks", { value: 789 });
       const first = await handle.receiveWithoutComplete("tasks");
       expect20(first).toEqual({ name: "tasks", body: { value: 789 } });
-      const retried = await handle.receiveOne("tasks", { timeout: 1e3 });
+      const retried = await handle.receiveOne("tasks", {
+        timeout: 1e3
+      });
       expect20(retried).toEqual({ name: "tasks", body: { value: 789 } });
     });
     test20("next throws when previous manual message is not completed", async (c) => {
@@ -3299,9 +3735,7 @@ function runActorQueueTests(driverTestConfig) {
         "manual-next-requires-complete"
       ]);
       await handle.send("tasks", { value: 111 });
-      const result = await handle.receiveManualThenNextWithoutComplete(
-        "tasks"
-      );
+      const result = await handle.receiveManualThenNextWithoutComplete("tasks");
       expect20(result).toEqual({
         group: "queue",
         code: "previous_message_not_completed"
@@ -3331,9 +3765,7 @@ function runActorQueueTests(driverTestConfig) {
     });
     test20("complete throws when called twice", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.queueActor.getOrCreate([
-        "complete-twice"
-      ]);
+      const handle = client.queueActor.getOrCreate(["complete-twice"]);
       await handle.send("twice", { value: "test" });
       const result = await handle.receiveAndCompleteTwice("twice");
       expect20(result).toEqual({
@@ -3398,9 +3830,7 @@ function runActorRunTests(driverTestConfig) {
     });
     test21("active run handler keeps actor awake past sleep timeout", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor = client.runWithTicks.getOrCreate([
-        "run-stays-awake"
-      ]);
+      const actor = client.runWithTicks.getOrCreate(["run-stays-awake"]);
       await waitFor(driverTestConfig, 100);
       const state1 = await actor.getState();
       expect21(state1.runStarted).toBe(true);
@@ -3460,100 +3890,184 @@ function runActorRunTests(driverTestConfig) {
       const state2 = await actor.getState();
       expect21(state2.wakeCount).toBeGreaterThan(state1.wakeCount);
     });
-    test21("run handler that exits early triggers destroy", async (c) => {
+    test21("run handler that exits early sleeps instead of destroying", async (c) => {
+      var _a2;
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.runWithEarlyExit.getOrCreate(["early-exit"]);
       await waitFor(driverTestConfig, 100);
       const state1 = await actor.getState();
       expect21(state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, 300);
-      const actor2 = client.runWithEarlyExit.getOrCreate([
-        "early-exit-fresh"
-      ]);
-      const state2 = await actor2.getState();
+      await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
+      const state2 = await actor.getState();
       expect21(state2.runStarted).toBe(true);
+      expect21(state2.destroyCalled).toBe(false);
+      if ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sleep) {
+        expect21(state2.sleepCount).toBe(0);
+        expect21(state2.wakeCount).toBe(1);
+      } else {
+        expect21(state2.sleepCount).toBeGreaterThan(0);
+        expect21(state2.wakeCount).toBeGreaterThan(1);
+      }
     });
-    test21("run handler that throws error triggers destroy", async (c) => {
+    test21("run handler that throws error sleeps instead of destroying", async (c) => {
+      var _a2;
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.runWithError.getOrCreate(["run-error"]);
       await waitFor(driverTestConfig, 100);
       const state1 = await actor.getState();
       expect21(state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, 300);
-      const actor2 = client.runWithError.getOrCreate(["run-error-fresh"]);
-      const state2 = await actor2.getState();
+      await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
+      const state2 = await actor.getState();
       expect21(state2.runStarted).toBe(true);
+      expect21(state2.destroyCalled).toBe(false);
+      if ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sleep) {
+        expect21(state2.sleepCount).toBe(0);
+        expect21(state2.wakeCount).toBe(1);
+      } else {
+        expect21(state2.sleepCount).toBeGreaterThan(0);
+        expect21(state2.wakeCount).toBeGreaterThan(1);
+      }
     });
   });
 }
 
+// src/driver-test-suite/tests/actor-sandbox.ts
+import { describe as describe23, expect as expect22, test as test22, vi as vi6 } from "vitest";
+function runActorSandboxTests(driverTestConfig) {
+  var _a;
+  describe23.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sandbox)("Actor Sandbox Tests", () => {
+    test22("supports sandbox actions through the actor runtime", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sandbox = client.dockerSandboxActor.getOrCreate([
+        `sandbox-${crypto.randomUUID()}`
+      ]);
+      const decoder = new TextDecoder();
+      const health = await vi6.waitFor(
+        async () => {
+          return await sandbox.getHealth();
+        },
+        {
+          timeout: 12e4,
+          interval: 500
+        }
+      );
+      expect22(typeof health.status).toBe("string");
+      const { url } = await sandbox.getSandboxUrl();
+      expect22(url).toMatch(/^https?:\/\//);
+      await sandbox.mkdirFs({ path: "/root/tmp" });
+      await sandbox.writeFsFile(
+        { path: "/root/tmp/hello.txt" },
+        "sandbox actor driver test"
+      );
+      expect22(
+        decoder.decode(
+          await sandbox.readFsFile({ path: "/root/tmp/hello.txt" })
+        )
+      ).toBe("sandbox actor driver test");
+      const stat = await sandbox.statFs({ path: "/root/tmp/hello.txt" });
+      expect22(stat.entryType).toBe("file");
+      await sandbox.moveFs({
+        from: "/root/tmp/hello.txt",
+        to: "/root/tmp/renamed.txt"
+      });
+      expect22(
+        (await sandbox.listFsEntries({ path: "/root/tmp" })).map(
+          (entry) => entry.name
+        )
+      ).toContain("renamed.txt");
+      await sandbox.dispose();
+      const healthAfterDispose = await vi6.waitFor(
+        async () => {
+          return await sandbox.getHealth();
+        },
+        {
+          timeout: 12e4,
+          interval: 500
+        }
+      );
+      expect22(typeof healthAfterDispose.status).toBe("string");
+      expect22(
+        decoder.decode(
+          await sandbox.readFsFile({ path: "/root/tmp/renamed.txt" })
+        )
+      ).toBe("sandbox actor driver test");
+      await sandbox.deleteFsEntry({ path: "/root/tmp", recursive: true });
+      expect22(await sandbox.listFsEntries({ path: "/root" })).not.toEqual(
+        expect22.arrayContaining([
+          expect22.objectContaining({ name: "tmp" })
+        ])
+      );
+    }, 18e4);
+  });
+}
+
 // src/driver-test-suite/tests/actor-stateless.ts
-import { describe as describe23, expect as expect22, test as test22 } from "vitest";
+import { describe as describe24, expect as expect23, test as test23 } from "vitest";
 function runActorStatelessTests(driverTestConfig) {
-  describe23("Actor Stateless Tests", () => {
-    describe23("Stateless Actor Operations", () => {
-      test22("can call actions on stateless actor", async (c) => {
+  describe24("Actor Stateless Tests", () => {
+    describe24("Stateless Actor Operations", () => {
+      test23("can call actions on stateless actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.statelessActor.getOrCreate();
         const result = await instance.ping();
-        expect22(result).toBe("pong");
+        expect23(result).toBe("pong");
       });
-      test22("can echo messages", async (c) => {
+      test23("can echo messages", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.statelessActor.getOrCreate();
         const message = "Hello, World!";
         const result = await instance.echo(message);
-        expect22(result).toBe(message);
+        expect23(result).toBe(message);
       });
-      test22("can access actorId", async (c) => {
+      test23("can access actorId", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.statelessActor.getOrCreate(["test-id"]);
         const actorId = await instance.getActorId();
-        expect22(actorId).toBeDefined();
-        expect22(typeof actorId).toBe("string");
+        expect23(actorId).toBeDefined();
+        expect23(typeof actorId).toBe("string");
       });
-      test22("accessing state throws StateNotEnabled", async (c) => {
+      test23("accessing state throws StateNotEnabled", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.statelessActor.getOrCreate();
         const result = await instance.tryGetState();
-        expect22(result.success).toBe(false);
-        expect22(result.error).toContain("state");
+        expect23(result.success).toBe(false);
+        expect23(result.error).toContain("state");
       });
-      test22("accessing db throws DatabaseNotEnabled", async (c) => {
+      test23("accessing db throws DatabaseNotEnabled", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.statelessActor.getOrCreate();
         const result = await instance.tryGetDb();
-        expect22(result.success).toBe(false);
-        expect22(result.error).toContain("database");
+        expect23(result.success).toBe(false);
+        expect23(result.error).toContain("database");
       });
-      test22("multiple stateless actors can exist independently", async (c) => {
+      test23("multiple stateless actors can exist independently", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const actor1 = client.statelessActor.getOrCreate(["actor-1"]);
         const actor2 = client.statelessActor.getOrCreate(["actor-2"]);
         const id1 = await actor1.getActorId();
         const id2 = await actor2.getActorId();
-        expect22(id1).not.toBe(id2);
+        expect23(id1).not.toBe(id2);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-vars.ts
-import { describe as describe24, expect as expect23, test as test23 } from "vitest";
+import { describe as describe25, expect as expect24, test as test24 } from "vitest";
 function runActorVarsTests(driverTestConfig) {
-  describe24("Actor Variables", () => {
-    describe24("Static vars", () => {
-      test23("should provide access to static vars", async (c) => {
+  describe25("Actor Variables", () => {
+    describe25("Static vars", () => {
+      test24("should provide access to static vars", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.staticVarActor.getOrCreate();
         const result = await instance.getVars();
-        expect23(result).toEqual({ counter: 42, name: "test-actor" });
+        expect24(result).toEqual({ counter: 42, name: "test-actor" });
         const name = await instance.getName();
-        expect23(name).toBe("test-actor");
+        expect24(name).toBe("test-actor");
       });
     });
-    describe24("Deep cloning of static vars", () => {
-      test23("should deep clone static vars between actor instances", async (c) => {
+    describe25("Deep cloning of static vars", () => {
+      test24("should deep clone static vars between actor instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.nestedVarActor.getOrCreate([
           "instance1"
@@ -3562,52 +4076,52 @@ function runActorVarsTests(driverTestConfig) {
           "instance2"
         ]);
         const modifiedVars = await instance1.modifyNested();
-        expect23(modifiedVars.nested.value).toBe("modified");
-        expect23(modifiedVars.nested.array).toContain(4);
-        expect23(modifiedVars.nested.obj.key).toBe("new-value");
+        expect24(modifiedVars.nested.value).toBe("modified");
+        expect24(modifiedVars.nested.array).toContain(4);
+        expect24(modifiedVars.nested.obj.key).toBe("new-value");
         const instance2Vars = await instance2.getVars();
-        expect23(instance2Vars.nested.value).toBe("original");
-        expect23(instance2Vars.nested.array).toEqual([1, 2, 3]);
-        expect23(instance2Vars.nested.obj.key).toBe("value");
+        expect24(instance2Vars.nested.value).toBe("original");
+        expect24(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect24(instance2Vars.nested.obj.key).toBe("value");
       });
     });
-    describe24("createVars", () => {
-      test23("should support dynamic vars creation", async (c) => {
+    describe25("createVars", () => {
+      test24("should support dynamic vars creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.dynamicVarActor.getOrCreate();
         const vars = await instance.getVars();
-        expect23(vars).toHaveProperty("random");
-        expect23(vars).toHaveProperty("computed");
-        expect23(typeof vars.random).toBe("number");
-        expect23(typeof vars.computed).toBe("string");
-        expect23(vars.computed).toMatch(/^Actor-\d+$/);
+        expect24(vars).toHaveProperty("random");
+        expect24(vars).toHaveProperty("computed");
+        expect24(typeof vars.random).toBe("number");
+        expect24(typeof vars.computed).toBe("string");
+        expect24(vars.computed).toMatch(/^Actor-\d+$/);
       });
-      test23("should create different vars for different instances", async (c) => {
+      test24("should create different vars for different instances", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.uniqueVarActor.getOrCreate(["test1"]);
         const instance2 = client.uniqueVarActor.getOrCreate(["test2"]);
         const vars1 = await instance1.getVars();
         const vars2 = await instance2.getVars();
-        expect23(vars1.id).not.toBe(vars2.id);
+        expect24(vars1.id).not.toBe(vars2.id);
       });
     });
-    describe24("Driver Context", () => {
-      test23("should provide access to driver context", async (c) => {
+    describe25("Driver Context", () => {
+      test24("should provide access to driver context", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance = client.driverCtxActor.getOrCreate();
         const vars = await instance.getVars();
-        expect23(vars).toHaveProperty("hasDriverCtx");
+        expect24(vars).toHaveProperty("hasDriverCtx");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-workflow.ts
-import { describe as describe25, expect as expect24, test as test24 } from "vitest";
+import { describe as describe26, expect as expect25, test as test25, vi as vi7 } from "vitest";
 function runActorWorkflowTests(driverTestConfig) {
-  describe25("Actor Workflow Tests", () => {
-    var _a;
-    test24("replays steps and guards state access", async (c) => {
+  describe26("Actor Workflow Tests", () => {
+    var _a, _b, _c, _d;
+    test25("replays steps and guards state access", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowCounterActor.getOrCreate([
         "workflow-basic"
@@ -3620,32 +4134,146 @@ function runActorWorkflowTests(driverTestConfig) {
         await waitFor(driverTestConfig, 100);
         state = await actor.getState();
       }
-      expect24(state.runCount).toBeGreaterThan(0);
-      expect24(state.history.length).toBeGreaterThan(0);
-      expect24(state.guardTriggered).toBe(true);
+      expect25(state.runCount).toBeGreaterThan(0);
+      expect25(state.history.length).toBeGreaterThan(0);
+      expect25(state.guardTriggered).toBe(true);
     });
-    test24("consumes queue messages via workflow queue.next", async (c) => {
+    test25("consumes queue messages via workflow queue.next", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor = client.workflowQueueActor.getOrCreate(["workflow-queue"]);
+      const actor = client.workflowQueueActor.getOrCreate([
+        "workflow-queue"
+      ]);
       await actor.send(WORKFLOW_QUEUE_NAME, {
         hello: "world"
       });
       await waitFor(driverTestConfig, 200);
       const messages = await actor.getMessages();
-      expect24(messages).toEqual([{ hello: "world" }]);
+      expect25(messages).toEqual([{ hello: "world" }]);
     });
-    test24("workflow queue.next supports completing wait sends", async (c) => {
+    test25("workflow queue.next supports completing wait sends", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowQueueActor.getOrCreate([
         "workflow-queue-wait"
       ]);
       const result = await actor.sendAndWait({ value: 123 });
-      expect24(result).toEqual({
+      expect25(result).toEqual({
         status: "completed",
         response: { echo: { value: 123 } }
       });
     });
-    test24("db and client are step-only in workflow context", async (c) => {
+    for (const testCase of [
+      {
+        name: "nested loops",
+        key: "loop",
+        getActor: (client) => client.workflowNestedLoopActor,
+        firstItems: ["a", "b"],
+        secondItems: ["c"],
+        expected: ["a", "b", "c"]
+      },
+      {
+        name: "nested joins",
+        key: "join",
+        getActor: (client) => client.workflowNestedJoinActor,
+        firstItems: ["a", "b"],
+        secondItems: ["c"],
+        expected: ["a", "b", "c"]
+      },
+      {
+        name: "nested races",
+        key: "race",
+        getActor: (client) => client.workflowNestedRaceActor,
+        firstItems: ["a"],
+        secondItems: ["b"],
+        expected: ["a", "b"]
+      }
+    ]) {
+      test25(
+        `replays ${testCase.name} across workflow queue iterations`,
+        async (c) => {
+          const { client } = await setupDriverTest(
+            c,
+            driverTestConfig
+          );
+          const actor = testCase.getActor(client).getOrCreate([
+            `workflow-nested-${testCase.key}`
+          ]);
+          const first = await actor.send(
+            WORKFLOW_NESTED_QUEUE_NAME,
+            {
+              items: testCase.firstItems
+            },
+            {
+              wait: true,
+              timeout: 1e3
+            }
+          );
+          expect25(first).toEqual({
+            status: "completed",
+            response: {
+              processed: testCase.firstItems.length
+            }
+          });
+          const second = await actor.send(
+            WORKFLOW_NESTED_QUEUE_NAME,
+            {
+              items: testCase.secondItems
+            },
+            {
+              wait: true,
+              timeout: 1e3
+            }
+          );
+          expect25(second).toEqual({
+            status: "completed",
+            response: {
+              processed: testCase.secondItems.length
+            }
+          });
+          const state = await actor.getState();
+          expect25(state.processed).toEqual(testCase.expected);
+        }
+      );
+    }
+    test25(
+      "starts child workflows created inside workflow steps",
+      async (c) => {
+        const { client } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const parent = client.workflowSpawnParentActor.getOrCreate([
+          "workflow-spawn-parent"
+        ]);
+        expect25(await parent.triggerSpawn("child-1")).toEqual({
+          queued: true
+        });
+        let parentState = await parent.getState();
+        for (let i = 0; i < 30 && parentState.results.length === 0; i++) {
+          await waitFor(driverTestConfig, 100);
+          parentState = await parent.getState();
+        }
+        expect25(parentState.results).toEqual([
+          {
+            key: "child-1",
+            result: {
+              status: "completed",
+              response: { ok: true }
+            },
+            error: null
+          }
+        ]);
+        const child = client.workflowSpawnChildActor.getOrCreate([
+          "child-1"
+        ]);
+        const childState = await child.getState();
+        expect25(childState).toEqual({
+          label: "child-1",
+          started: true,
+          processed: ["hello"]
+        });
+      }
+    );
+    test25("db and client are step-only in workflow context", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowAccessActor.getOrCreate([
         "workflow-access"
@@ -3655,24 +4283,215 @@ function runActorWorkflowTests(driverTestConfig) {
         await waitFor(driverTestConfig, 50);
         state = await actor.getState();
       }
-      expect24(state.outsideDbError).toBe(
+      expect25(state.outsideDbError).toBe(
         "db is only available inside workflow steps"
       );
-      expect24(state.outsideClientError).toBe(
+      expect25(state.outsideClientError).toBe(
         "client is only available inside workflow steps"
       );
-      expect24(state.insideDbCount).toBeGreaterThan(0);
-      expect24(state.insideClientAvailable).toBe(true);
+      expect25(state.insideDbCount).toBeGreaterThan(0);
+      expect25(state.insideClientAvailable).toBe(true);
     });
-    test24("sleeps and resumes between ticks", async (c) => {
+    test25("sleeps and resumes between ticks", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor = client.workflowSleepActor.getOrCreate(["workflow-sleep"]);
+      const actor = client.workflowSleepActor.getOrCreate([
+        "workflow-sleep"
+      ]);
       const initial = await actor.getState();
       await waitFor(driverTestConfig, 200);
       const next = await actor.getState();
-      expect24(next.ticks).toBeGreaterThan(initial.ticks);
+      expect25(next.ticks).toBeGreaterThan(initial.ticks);
     });
-    test24.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)(
+    test25("workflow onError reports retry metadata", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowErrorHookActor.getOrCreate([
+        "workflow-error-hook"
+      ]);
+      let state = await actor.getErrorState();
+      for (let i = 0; i < 80 && (state.attempts < 2 || state.events.length === 0); i++) {
+        await waitFor(driverTestConfig, 50);
+        state = await actor.getErrorState();
+      }
+      expect25(state.attempts).toBe(2);
+      expect25(state.events).toHaveLength(1);
+      expect25(state.events[0]).toEqual(
+        expect25.objectContaining({
+          step: expect25.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: expect25.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
+    test25("workflow onError can update actor state", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowErrorHookEffectsActor.getOrCreate([
+        "workflow-error-state"
+      ]);
+      await actor.startWorkflow();
+      let state = await actor.getErrorState();
+      for (let i = 0; i < 80 && (state.attempts < 2 || state.lastError === null || state.errorCount === 0); i++) {
+        await waitFor(driverTestConfig, 50);
+        state = await actor.getErrorState();
+      }
+      expect25(state.attempts).toBe(2);
+      expect25(state.errorCount).toBe(1);
+      expect25(state.lastError).toEqual(
+        expect25.objectContaining({
+          step: expect25.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: expect25.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
+    test25("workflow onError can broadcast actor events", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowErrorHookEffectsActor.getOrCreate(["workflow-error-broadcast"]).connect();
+      try {
+        const eventPromise = new Promise((resolve) => {
+          actor.once("workflowError", resolve);
+        });
+        await actor.startWorkflow();
+        const event = await eventPromise;
+        expect25(event).toEqual(
+          expect25.objectContaining({
+            step: expect25.objectContaining({
+              stepName: "flaky",
+              attempt: 1,
+              willRetry: true,
+              retryDelay: 1,
+              error: expect25.objectContaining({
+                name: "Error",
+                message: "workflow hook failed"
+              })
+            })
+          })
+        );
+      } finally {
+        await actor.dispose();
+      }
+    });
+    test25("workflow onError can enqueue actor messages", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor = client.workflowErrorHookEffectsActor.getOrCreate([
+        "workflow-error-queue"
+      ]);
+      await actor.startWorkflow();
+      const queuedError = await actor.receiveQueuedError();
+      expect25(queuedError).toEqual(
+        expect25.objectContaining({
+          step: expect25.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: expect25.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
+    test25.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)(
+      "completed workflows sleep instead of destroying the actor",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.workflowCompleteActor.getOrCreate([
+          "workflow-complete"
+        ]);
+        let state = await actor.getState();
+        for (let i = 0; i < 10 && state.sleepCount === 0; i++) {
+          await waitFor(driverTestConfig, 100);
+          state = await actor.getState();
+        }
+        expect25(state.runCount).toBeGreaterThan(0);
+        expect25(state.sleepCount).toBeGreaterThan(0);
+        expect25(state.startCount).toBeGreaterThan(1);
+      }
+    );
+    test25("workflow steps can destroy the actor", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = "workflow-destroy";
+      const observer = client.destroyObserver.getOrCreate(["observer"]);
+      await observer.reset();
+      const actor = client.workflowDestroyActor.getOrCreate([actorKey]);
+      const actorId = await actor.resolve();
+      await vi7.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        expect25(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await vi7.waitFor(async () => {
+        let actorRunning = false;
+        try {
+          await client.workflowDestroyActor.getForId(actorId).resolve();
+          actorRunning = true;
+        } catch (err) {
+          expect25(err.group).toBe("actor");
+          expect25(err.code).toBe("not_found");
+        }
+        expect25(actorRunning, "actor still running").toBeFalsy();
+      });
+    });
+    test25.skipIf((_b = driverTestConfig.skip) == null ? void 0 : _b.sleep)(
+      "failed workflow steps sleep instead of surfacing as run errors",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.workflowFailedStepActor.getOrCreate([
+          "workflow-failed-step"
+        ]);
+        let state = await actor.getState();
+        for (let i = 0; i < 10 && state.sleepCount === 0; i++) {
+          await waitFor(driverTestConfig, 100);
+          state = await actor.getState();
+        }
+        expect25(state.runCount).toBeGreaterThan(0);
+        expect25(state.sleepCount).toBeGreaterThan(0);
+        expect25(state.startCount).toBeGreaterThan(1);
+      }
+    );
+    test25.skipIf((_c = driverTestConfig.skip) == null ? void 0 : _c.sleep)(
+      "workflow onError is not reported again after sleep and wake",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.workflowErrorHookSleepActor.getOrCreate([
+          "workflow-error-hook-sleep"
+        ]);
+        let state = await actor.getErrorState();
+        for (let i = 0; i < 80 && (state.attempts < 2 || state.events.length === 0); i++) {
+          await waitFor(driverTestConfig, 50);
+          state = await actor.getErrorState();
+        }
+        expect25(state.attempts).toBe(2);
+        expect25(state.events).toHaveLength(1);
+        expect25(state.wakeCount).toBe(1);
+        await actor.triggerSleep();
+        await waitFor(driverTestConfig, 250);
+        let resumedState = await actor.getErrorState();
+        for (let i = 0; i < 40 && (resumedState.wakeCount < 2 || resumedState.sleepCount < 1); i++) {
+          await waitFor(driverTestConfig, 50);
+          resumedState = await actor.getErrorState();
+        }
+        expect25(resumedState.sleepCount).toBeGreaterThanOrEqual(1);
+        expect25(resumedState.wakeCount).toBeGreaterThanOrEqual(2);
+        expect25(resumedState.attempts).toBe(2);
+        expect25(resumedState.events).toHaveLength(1);
+      }
+    );
+    test25.skipIf((_d = driverTestConfig.skip) == null ? void 0 : _d.sleep)(
       "workflow run teardown does not wait for runStopTimeout",
       async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -3682,69 +4501,69 @@ function runActorWorkflowTests(driverTestConfig) {
         await actor.getTimeline();
         await waitFor(driverTestConfig, 1200);
         const timeline = await actor.getTimeline();
-        expect24(timeline.wakeAts.length).toBeGreaterThanOrEqual(2);
-        expect24(timeline.sleepAts.length).toBeGreaterThanOrEqual(1);
+        expect25(timeline.wakeAts.length).toBeGreaterThanOrEqual(2);
+        expect25(timeline.sleepAts.length).toBeGreaterThanOrEqual(1);
         const firstSleepDelayMs = timeline.sleepAts[0] - timeline.wakeAts[0];
-        expect24(firstSleepDelayMs).toBeLessThan(1800);
+        expect25(firstSleepDelayMs).toBeLessThan(1800);
       }
     );
   });
 }
 
 // src/driver-test-suite/tests/manager-driver.ts
-import { describe as describe26, expect as expect25, test as test25 } from "vitest";
+import { describe as describe27, expect as expect26, test as test26 } from "vitest";
 function runManagerDriverTests(driverTestConfig) {
-  describe26("Manager Driver Tests", () => {
-    describe26("Client Connection Methods", () => {
-      test25("connect() - finds or creates a actor", async (c) => {
+  describe27("Manager Driver Tests", () => {
+    describe27("Client Connection Methods", () => {
+      test26("connect() - finds or creates a actor", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counterA = client.counter.getOrCreate();
         await counterA.increment(5);
         const counterAAgain = client.counter.getOrCreate();
         const count = await counterAAgain.increment(0);
-        expect25(count).toBe(5);
+        expect26(count).toBe(5);
         const counterB = client.counter.getOrCreate([
           "counter-b",
           "testing"
         ]);
         await counterB.increment(10);
         const countB = await counterB.increment(0);
-        expect25(countB).toBe(10);
+        expect26(countB).toBe(10);
       });
-      test25("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+      test26("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = ["duplicate-actor-test", crypto.randomUUID()];
         const counter = client.counter.getOrCreate(uniqueKey);
         await counter.increment(5);
         try {
           await client.counter.create(uniqueKey);
-          expect25.fail("did not error on duplicate create");
+          expect26.fail("did not error on duplicate create");
         } catch (err) {
-          expect25(err.group).toBe("actor");
-          expect25(err.code).toBe("duplicate_key");
+          expect26(err.group).toBe("actor");
+          expect26(err.code).toBe("duplicate_key");
         }
         const count = await counter.increment(0);
-        expect25(count).toBe(5);
+        expect26(count).toBe(5);
       });
     });
-    describe26("Connection Options", () => {
-      test25("get without create prevents actor creation", async (c) => {
+    describe27("Connection Options", () => {
+      test26("get without create prevents actor creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const nonexistentId = `nonexistent-${crypto.randomUUID()}`;
         try {
           await client.counter.get([nonexistentId]).resolve();
-          expect25.fail("did not error for get");
+          expect26.fail("did not error for get");
         } catch (err) {
-          expect25(err.group).toBe("actor");
-          expect25(err.code).toBe("not_found");
+          expect26(err.group).toBe("actor");
+          expect26(err.code).toBe("not_found");
         }
         const createdCounter = client.counter.getOrCreate(nonexistentId);
         await createdCounter.increment(3);
         const retrievedCounter = client.counter.get(nonexistentId);
         const count = await retrievedCounter.increment(0);
-        expect25(count).toBe(3);
+        expect26(count).toBe(3);
       });
-      test25("connection params are passed to actors", async (c) => {
+      test26("connection params are passed to actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counter = client.counter.getOrCreate(void 0, {
           params: {
@@ -3755,20 +4574,20 @@ function runManagerDriverTests(driverTestConfig) {
         });
         await counter.increment(1);
         const count = await counter.increment(0);
-        expect25(count).toBe(1);
+        expect26(count).toBe(1);
       });
     });
-    describe26("Actor Creation & Retrieval", () => {
-      test25("creates and retrieves actors by ID", async (c) => {
+    describe27("Actor Creation & Retrieval", () => {
+      test26("creates and retrieves actors by ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueId = `test-counter-${crypto.randomUUID()}`;
         const counter = client.counter.getOrCreate([uniqueId]);
         await counter.increment(10);
         const retrievedCounter = client.counter.getOrCreate([uniqueId]);
         const count = await retrievedCounter.increment(0);
-        expect25(count).toBe(10);
+        expect26(count).toBe(10);
       });
-      test25("passes input to actor during creation", async (c) => {
+      test26("passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const testInput = {
           name: "test-actor",
@@ -3779,17 +4598,17 @@ function runManagerDriverTests(driverTestConfig) {
           input: testInput
         });
         const inputs = await actor.getInputs();
-        expect25(inputs.initialInput).toEqual(testInput);
-        expect25(inputs.onCreateInput).toEqual(testInput);
+        expect26(inputs.initialInput).toEqual(testInput);
+        expect26(inputs.onCreateInput).toEqual(testInput);
       });
-      test25("input is undefined when not provided", async (c) => {
+      test26("input is undefined when not provided", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const actor = await client.inputActor.create();
         const inputs = await actor.getInputs();
-        expect25(inputs.initialInput).toBeUndefined();
-        expect25(inputs.onCreateInput).toBeUndefined();
+        expect26(inputs.initialInput).toBeUndefined();
+        expect26(inputs.onCreateInput).toBeUndefined();
       });
-      test25("getOrCreate passes input to actor during creation", async (c) => {
+      test26("getOrCreate passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = [`input-test-${crypto.randomUUID()}`];
         const testInput = {
@@ -3801,22 +4620,22 @@ function runManagerDriverTests(driverTestConfig) {
           createWithInput: testInput
         });
         const inputs = await actor.getInputs();
-        expect25(inputs.initialInput).toEqual(testInput);
-        expect25(inputs.onCreateInput).toEqual(testInput);
+        expect26(inputs.initialInput).toEqual(testInput);
+        expect26(inputs.onCreateInput).toEqual(testInput);
         const existingActor = client.inputActor.getOrCreate(uniqueKey);
         const existingInputs = await existingActor.getInputs();
-        expect25(existingInputs.initialInput).toEqual(testInput);
-        expect25(existingInputs.onCreateInput).toEqual(testInput);
+        expect26(existingInputs.initialInput).toEqual(testInput);
+        expect26(existingInputs.onCreateInput).toEqual(testInput);
       });
     });
-    describe26("Key Matching", () => {
-      test25("multi-part actor keys are passed through correctly", async (c) => {
+    describe27("Key Matching", () => {
+      test26("multi-part actor keys are passed through correctly", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const multiPartKey = ["tenant/with/slash", "room"];
         const counter = client.counter.getOrCreate(multiPartKey);
-        expect25(await counter.getKey()).toEqual(multiPartKey);
+        expect26(await counter.getKey()).toEqual(multiPartKey);
       });
-      test25("matches actors only with exactly the same keys", async (c) => {
+      test26("matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
           "counter-match",
@@ -3830,20 +4649,20 @@ function runManagerDriverTests(driverTestConfig) {
           "us-east"
         ]);
         const exactMatchCount = await exactMatchCounter.increment(0);
-        expect25(exactMatchCount).toBe(10);
+        expect26(exactMatchCount).toBe(10);
         const subsetMatchCounter = client.counter.getOrCreate([
           "counter-match",
           "test"
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
-        expect25(subsetMatchCount).toBe(0);
+        expect26(subsetMatchCount).toBe(0);
         const singleKeyCounter = client.counter.getOrCreate([
           "counter-match"
         ]);
         const singleKeyCount = await singleKeyCounter.increment(0);
-        expect25(singleKeyCount).toBe(0);
+        expect26(singleKeyCount).toBe(0);
       });
-      test25("string key matches array with single string key", async (c) => {
+      test26("string key matches array with single string key", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const stringKeyCounter = client.counter.getOrCreate("string-key-test");
         await stringKeyCounter.increment(7);
@@ -3851,20 +4670,20 @@ function runManagerDriverTests(driverTestConfig) {
           "string-key-test"
         ]);
         const count = await arrayKeyCounter.increment(0);
-        expect25(count).toBe(7);
+        expect26(count).toBe(7);
       });
-      test25("undefined key matches empty array key and no key", async (c) => {
+      test26("undefined key matches empty array key and no key", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const undefinedKeyCounter = client.counter.getOrCreate(void 0);
         await undefinedKeyCounter.increment(12);
         const emptyArrayKeyCounter = client.counter.getOrCreate([]);
         const emptyArrayCount = await emptyArrayKeyCounter.increment(0);
-        expect25(emptyArrayCount).toBe(12);
+        expect26(emptyArrayCount).toBe(12);
         const noKeyCounter = client.counter.getOrCreate();
         const noKeyCount = await noKeyCounter.increment(0);
-        expect25(noKeyCount).toBe(12);
+        expect26(noKeyCount).toBe(12);
       });
-      test25("no keys does not match actors with keys", async (c) => {
+      test26("no keys does not match actors with keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const keyedCounter = client.counter.getOrCreate([
           "counter-with-keys",
@@ -3873,9 +4692,9 @@ function runManagerDriverTests(driverTestConfig) {
         await keyedCounter.increment(15);
         const noKeysCounter = client.counter.getOrCreate();
         const count = await noKeysCounter.increment(10);
-        expect25(count).toBe(10);
+        expect26(count).toBe(10);
       });
-      test25("actors with keys match actors with no keys", async (c) => {
+      test26("actors with keys match actors with no keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const noKeysCounter = client.counter.getOrCreate();
         await noKeysCounter.increment(25);
@@ -3884,11 +4703,11 @@ function runManagerDriverTests(driverTestConfig) {
           "prod"
         ]);
         const keyedCount = await keyedCounter.increment(0);
-        expect25(keyedCount).toBe(0);
+        expect26(keyedCount).toBe(0);
       });
     });
-    describe26("Multiple Actor Instances", () => {
-      test25("creates multiple actor instances of the same type", async (c) => {
+    describe27("Multiple Actor Instances", () => {
+      test26("creates multiple actor instances of the same type", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const instance1 = client.counter.getOrCreate(["multi-1"]);
         const instance2 = client.counter.getOrCreate(["multi-2"]);
@@ -3899,35 +4718,35 @@ function runManagerDriverTests(driverTestConfig) {
         const retrieved1 = client.counter.getOrCreate(["multi-1"]);
         const retrieved2 = client.counter.getOrCreate(["multi-2"]);
         const retrieved3 = client.counter.getOrCreate(["multi-3"]);
-        expect25(await retrieved1.increment(0)).toBe(1);
-        expect25(await retrieved2.increment(0)).toBe(2);
-        expect25(await retrieved3.increment(0)).toBe(3);
+        expect26(await retrieved1.increment(0)).toBe(1);
+        expect26(await retrieved2.increment(0)).toBe(2);
+        expect26(await retrieved3.increment(0)).toBe(3);
       });
-      test25("handles default instance with no explicit ID", async (c) => {
+      test26("handles default instance with no explicit ID", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const defaultCounter = client.counter.getOrCreate();
         await defaultCounter.increment(5);
         const sameDefaultCounter = client.counter.getOrCreate();
         const count = await sameDefaultCounter.increment(0);
-        expect25(count).toBe(5);
+        expect26(count).toBe(5);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http.ts
-import { describe as describe27, expect as expect26, test as test26 } from "vitest";
+import { describe as describe28, expect as expect27, test as test27 } from "vitest";
 function runRawHttpTests(driverTestConfig) {
-  describe27("raw http", () => {
-    test26("should handle raw HTTP GET requests", async (c) => {
+  describe28("raw http", () => {
+    test27("should handle raw HTTP GET requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["test"]);
       const helloResponse = await actor.fetch("api/hello");
-      expect26(helloResponse.ok).toBe(true);
+      expect27(helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
-      expect26(helloData).toEqual({ message: "Hello from actor!" });
+      expect27(helloData).toEqual({ message: "Hello from actor!" });
     });
-    test26("should handle raw HTTP POST requests with echo", async (c) => {
+    test27("should handle raw HTTP POST requests with echo", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["test"]);
       const testData = { test: "data", number: 123 };
@@ -3938,22 +4757,22 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: JSON.stringify(testData)
       });
-      expect26(echoResponse.ok).toBe(true);
+      expect27(echoResponse.ok).toBe(true);
       const echoData = await echoResponse.json();
-      expect26(echoData).toEqual(testData);
+      expect27(echoData).toEqual(testData);
     });
-    test26("should track state across raw HTTP requests", async (c) => {
+    test27("should track state across raw HTTP requests", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["state-test"]);
       await actor.fetch("api/hello");
       await actor.fetch("api/hello");
       await actor.fetch("api/state");
       const stateResponse = await actor.fetch("api/state");
-      expect26(stateResponse.ok).toBe(true);
+      expect27(stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
-      expect26(stateData.requestCount).toBe(4);
+      expect27(stateData.requestCount).toBe(4);
     });
-    test26("should pass headers correctly", async (c) => {
+    test27("should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
@@ -3963,44 +4782,44 @@ function runRawHttpTests(driverTestConfig) {
       const response = await actor.fetch("api/headers", {
         headers: customHeaders
       });
-      expect26(response.ok).toBe(true);
+      expect27(response.ok).toBe(true);
       const headers = await response.json();
-      expect26(headers["x-custom-header"]).toBe("test-value");
-      expect26(headers["x-another-header"]).toBe("another-value");
+      expect27(headers["x-custom-header"]).toBe("test-value");
+      expect27(headers["x-another-header"]).toBe("another-value");
     });
-    test26("should return 404 for unhandled paths", async (c) => {
+    test27("should return 404 for unhandled paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["404-test"]);
       const response = await actor.fetch("api/nonexistent");
-      expect26(response.ok).toBe(false);
-      expect26(response.status).toBe(404);
+      expect27(response.ok).toBe(false);
+      expect27(response.status).toBe(404);
     });
-    test26("should return 404 when no onRequest handler defined", async (c) => {
+    test27("should return 404 when no onRequest handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpNoHandlerActor.getOrCreate([
         "no-handler"
       ]);
       const response = await actor.fetch("api/anything");
-      expect26(response.ok).toBe(false);
-      expect26(response.status).toBe(404);
+      expect27(response.ok).toBe(false);
+      expect27(response.status).toBe(404);
     });
-    test26("should return 500 error when onRequest returns void", async (c) => {
+    test27("should return 500 error when onRequest returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpVoidReturnActor.getOrCreate([
         "void-return"
       ]);
       const response = await actor.fetch("api/anything");
-      expect26(response.ok).toBe(false);
-      expect26(response.status).toBe(500);
+      expect27(response.ok).toBe(false);
+      expect27(response.status).toBe(500);
       try {
         const errorData = await response.json();
-        expect26(errorData.message).toContain(
+        expect27(errorData.message).toContain(
           "onRequest handler must return a Response"
         );
       } catch {
       }
     });
-    test26("should handle different HTTP methods", async (c) => {
+    test27("should handle different HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["methods-test"]);
       const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
@@ -4010,17 +4829,17 @@ function runRawHttpTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "POST") {
-          expect26(response.ok).toBe(true);
+          expect27(response.ok).toBe(true);
           const data = await response.json();
-          expect26(data).toEqual({ method });
+          expect27(data).toEqual({ method });
         } else if (method === "GET") {
-          expect26(response.status).toBe(404);
+          expect27(response.status).toBe(404);
         } else {
-          expect26(response.status).toBe(404);
+          expect27(response.status).toBe(404);
         }
       }
     });
-    test26("should handle binary data", async (c) => {
+    test27("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["binary-test"]);
       const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
@@ -4031,82 +4850,82 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: binaryData
       });
-      expect26(response.ok).toBe(true);
+      expect27(response.ok).toBe(true);
       const responseBuffer = await response.arrayBuffer();
       const responseArray = new Uint8Array(responseBuffer);
-      expect26(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+      expect27(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
     });
-    test26("should work with Hono router using createVars", async (c) => {
+    test27("should work with Hono router using createVars", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
       const rootResponse = await actor.fetch("/");
-      expect26(rootResponse.ok).toBe(true);
+      expect27(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect26(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      expect27(rootData).toEqual({ message: "Welcome to Hono actor!" });
       const usersResponse = await actor.fetch("/users");
-      expect26(usersResponse.ok).toBe(true);
+      expect27(usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
-      expect26(users).toEqual([
+      expect27(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
       const userResponse = await actor.fetch("/users/1");
-      expect26(userResponse.ok).toBe(true);
+      expect27(userResponse.ok).toBe(true);
       const user = await userResponse.json();
-      expect26(user).toEqual({ id: 1, name: "Alice" });
+      expect27(user).toEqual({ id: 1, name: "Alice" });
       const newUser = { name: "Charlie" };
       const createResponse = await actor.fetch("/users", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(newUser)
       });
-      expect26(createResponse.ok).toBe(true);
-      expect26(createResponse.status).toBe(201);
+      expect27(createResponse.ok).toBe(true);
+      expect27(createResponse.status).toBe(201);
       const createdUser = await createResponse.json();
-      expect26(createdUser).toEqual({ id: 3, name: "Charlie" });
+      expect27(createdUser).toEqual({ id: 3, name: "Charlie" });
       const updateData = { name: "Alice Updated" };
       const updateResponse = await actor.fetch("/users/1", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(updateData)
       });
-      expect26(updateResponse.ok).toBe(true);
+      expect27(updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
-      expect26(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      expect27(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
       const deleteResponse = await actor.fetch("/users/2", {
         method: "DELETE"
       });
-      expect26(deleteResponse.ok).toBe(true);
+      expect27(deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
-      expect26(deleteResult).toEqual({ message: "User 2 deleted" });
+      expect27(deleteResult).toEqual({ message: "User 2 deleted" });
       const notFoundResponse = await actor.fetch("/api/unknown");
-      expect26(notFoundResponse.ok).toBe(false);
-      expect26(notFoundResponse.status).toBe(404);
+      expect27(notFoundResponse.ok).toBe(false);
+      expect27(notFoundResponse.status).toBe(404);
     });
-    test26("should handle paths with and without leading slashes", async (c) => {
+    test27("should handle paths with and without leading slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["path-test"]);
       const responseWithoutSlash = await actor.fetch("api/hello");
-      expect26(responseWithoutSlash.ok).toBe(true);
+      expect27(responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
-      expect26(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      expect27(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
       const responseWithSlash = await actor.fetch("/api/hello");
-      expect26(responseWithSlash.ok).toBe(true);
+      expect27(responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
-      expect26(dataWithSlash).toEqual({ message: "Hello from actor!" });
+      expect27(dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
-    test26("should not create double slashes in request URLs", async (c) => {
+    test27("should not create double slashes in request URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["url-test"]);
       const response = await actor.fetch("/users");
-      expect26(response.ok).toBe(true);
+      expect27(response.ok).toBe(true);
       const data = await response.json();
-      expect26(data).toEqual([
+      expect27(data).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test26("should handle forwarded requests correctly without double slashes", async (c) => {
+    test27("should handle forwarded requests correctly without double slashes", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
       const truncatedPath = "/users";
@@ -4118,14 +4937,14 @@ function runRawHttpTests(driverTestConfig) {
         truncatedPath,
         newRequest
       );
-      expect26(response.ok).toBe(true);
+      expect27(response.ok).toBe(true);
       const users = await response.json();
-      expect26(users).toEqual([
+      expect27(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test26("example fix: should properly forward requests using just Request object", async (c) => {
+    test27("example fix: should properly forward requests using just Request object", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
       const truncatedPath = "/users/1";
@@ -4134,11 +4953,11 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor.fetch(newRequest);
-      expect26(response.ok).toBe(true);
+      expect27(response.ok).toBe(true);
       const user = await response.json();
-      expect26(user).toEqual({ id: 1, name: "Alice" });
+      expect27(user).toEqual({ id: 1, name: "Alice" });
     });
-    test26("should support standard fetch API with URL and Request objects", async (c) => {
+    test27("should support standard fetch API with URL and Request objects", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
       const url = new URL("/api/echo", "http://example.com");
@@ -4147,18 +4966,18 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
       });
-      expect26(urlResponse.ok).toBe(true);
+      expect27(urlResponse.ok).toBe(true);
       const urlData = await urlResponse.json();
-      expect26(urlData).toEqual({ from: "URL object" });
+      expect27(urlData).toEqual({ from: "URL object" });
       const request = new Request("http://example.com/api/echo", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "Request object" })
       });
       const requestResponse = await actor.fetch(request);
-      expect26(requestResponse.ok).toBe(true);
+      expect27(requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
-      expect26(requestData).toEqual({ from: "Request object" });
+      expect27(requestData).toEqual({ from: "Request object" });
       const request2 = new Request("http://example.com/api/headers", {
         method: "GET",
         headers: { "X-Original": "request-header" }
@@ -4166,19 +4985,19 @@ function runRawHttpTests(driverTestConfig) {
       const overrideResponse = await actor.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
-      expect26(overrideResponse.ok).toBe(true);
+      expect27(overrideResponse.ok).toBe(true);
       const headers = await overrideResponse.json();
-      expect26(headers["x-override"]).toBe("init-header");
-      expect26(headers["x-original"]).toBe("request-header");
+      expect27(headers["x-override"]).toBe("init-header");
+      expect27(headers["x-original"]).toBe("request-header");
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http-request-properties.ts
-import { describe as describe28, expect as expect27, test as test27 } from "vitest";
+import { describe as describe29, expect as expect28, test as test28 } from "vitest";
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
-  describe28("raw http request properties", () => {
-    test27("should pass all Request properties correctly to onRequest", async (c) => {
+  describe29("raw http request properties", () => {
+    test28("should pass all Request properties correctly to onRequest", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4192,22 +5011,22 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify({ test: "data" })
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.url).toContain("/test/path?foo=bar&baz=qux");
-      expect27(data.pathname).toBe("/test/path");
-      expect27(data.search).toBe("?foo=bar&baz=qux");
-      expect27(data.searchParams).toEqual({
+      expect28(data.url).toContain("/test/path?foo=bar&baz=qux");
+      expect28(data.pathname).toBe("/test/path");
+      expect28(data.search).toBe("?foo=bar&baz=qux");
+      expect28(data.searchParams).toEqual({
         foo: "bar",
         baz: "qux"
       });
-      expect27(data.method).toBe("POST");
-      expect27(data.headers["content-type"]).toBe("application/json");
-      expect27(data.headers["x-custom-header"]).toBe("custom-value");
-      expect27(data.headers["authorization"]).toBe("Bearer test-token");
-      expect27(data.body).toEqual({ test: "data" });
+      expect28(data.method).toBe("POST");
+      expect28(data.headers["content-type"]).toBe("application/json");
+      expect28(data.headers["x-custom-header"]).toBe("custom-value");
+      expect28(data.headers["authorization"]).toBe("Bearer test-token");
+      expect28(data.body).toEqual({ test: "data" });
     });
-    test27("should handle GET requests with no body", async (c) => {
+    test28("should handle GET requests with no body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4215,12 +5034,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch("test/get", {
         method: "GET"
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.method).toBe("GET");
-      expect27(data.body).toBeNull();
+      expect28(data.method).toBe("GET");
+      expect28(data.body).toBeNull();
     });
-    test27("should handle different content types", async (c) => {
+    test28("should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4235,12 +5054,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: formData.toString()
       });
-      expect27(formResponse.ok).toBe(true);
+      expect28(formResponse.ok).toBe(true);
       const formResult = await formResponse.json();
-      expect27(formResult.headers["content-type"]).toBe(
+      expect28(formResult.headers["content-type"]).toBe(
         "application/x-www-form-urlencoded"
       );
-      expect27(formResult.bodyText).toBe("field1=value1&field2=value2");
+      expect28(formResult.bodyText).toBe("field1=value1&field2=value2");
       const textResponse = await actor.fetch("test/text", {
         method: "POST",
         headers: {
@@ -4248,12 +5067,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: "Hello, World!"
       });
-      expect27(textResponse.ok).toBe(true);
+      expect28(textResponse.ok).toBe(true);
       const textResult = await textResponse.json();
-      expect27(textResult.headers["content-type"]).toBe("text/plain");
-      expect27(textResult.bodyText).toBe("Hello, World!");
+      expect28(textResult.headers["content-type"]).toBe("text/plain");
+      expect28(textResult.bodyText).toBe("Hello, World!");
     });
-    test27("should preserve all header casing and values", async (c) => {
+    test28("should preserve all header casing and values", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4267,38 +5086,38 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           "X-Request-ID": "12345"
         }
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.headers["accept"]).toBe("application/json");
-      expect27(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
-      expect27(data.headers["cache-control"]).toBe("no-cache");
-      expect27(data.headers["user-agent"]).toBeTruthy();
-      expect27(data.headers["x-request-id"]).toBe("12345");
+      expect28(data.headers["accept"]).toBe("application/json");
+      expect28(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
+      expect28(data.headers["cache-control"]).toBe("no-cache");
+      expect28(data.headers["user-agent"]).toBeTruthy();
+      expect28(data.headers["x-request-id"]).toBe("12345");
     });
-    test27("should handle empty and special URL paths", async (c) => {
+    test28("should handle empty and special URL paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const rootResponse = await actor.fetch("");
-      expect27(rootResponse.ok).toBe(true);
+      expect28(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect27(rootData.pathname).toBe("/");
+      expect28(rootData.pathname).toBe("/");
       const specialResponse = await actor.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
-      expect27(specialResponse.ok).toBe(true);
+      expect28(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect27(specialData.pathname).toMatch(
+      expect28(specialData.pathname).toMatch(
         /path.*with.*spaces.*and.*slashes/
       );
       const fragmentResponse = await actor.fetch("test/path#fragment");
-      expect27(fragmentResponse.ok).toBe(true);
+      expect28(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
-      expect27(fragmentData.pathname).toBe("/test/path");
-      expect27(fragmentData.hash).toBe("");
+      expect28(fragmentData.pathname).toBe("/test/path");
+      expect28(fragmentData.hash).toBe("");
     });
-    test27("should handle request properties for all HTTP methods", async (c) => {
+    test28("should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4322,21 +5141,21 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           }
         );
         if (method === "HEAD") {
-          expect27(response.status).toBe(200);
+          expect28(response.status).toBe(200);
           const text = await response.text();
-          expect27(text).toBe("");
+          expect28(text).toBe("");
         } else if (method === "OPTIONS") {
-          expect27(response.status).toBe(204);
+          expect28(response.status).toBe(204);
           const text = await response.text();
-          expect27(text).toBe("");
+          expect28(text).toBe("");
         } else {
-          expect27(response.ok).toBe(true);
+          expect28(response.ok).toBe(true);
           const data = await response.json();
-          expect27(data.method).toBe(method);
+          expect28(data.method).toBe(method);
         }
       }
     });
-    test27("should handle complex query parameters", async (c) => {
+    test28("should handle complex query parameters", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4344,13 +5163,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch(
         "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
       );
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.searchParams.key).toBe("value2");
-      expect27(data.searchParams["array[]"]).toBe("2");
-      expect27(data.searchParams["nested[prop]"]).toBe("val");
+      expect28(data.searchParams.key).toBe("value2");
+      expect28(data.searchParams["array[]"]).toBe("2");
+      expect28(data.searchParams["nested[prop]"]).toBe("val");
     });
-    test27("should handle multipart form data", async (c) => {
+    test28("should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4374,27 +5193,27 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.headers["content-type"]).toContain(
+      expect28(data.headers["content-type"]).toContain(
         "multipart/form-data"
       );
-      expect27(data.bodyText).toContain("field1");
-      expect27(data.bodyText).toContain("value1");
+      expect28(data.bodyText).toContain("field1");
+      expect28(data.bodyText).toContain("value1");
     });
-    test27("should handle very long URLs", async (c) => {
+    test28("should handle very long URLs", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
       ]);
       const longValue = "x".repeat(1e3);
       const response = await actor.fetch(`test/long?param=${longValue}`);
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.searchParams.param).toBe(longValue);
-      expect27(data.search.length).toBeGreaterThan(1e3);
+      expect28(data.searchParams.param).toBe(longValue);
+      expect28(data.search.length).toBeGreaterThan(1e3);
     });
-    test27.skip("should handle large request bodies", async (c) => {
+    test28.skip("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4411,11 +5230,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify(largeArray)
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.body).toHaveLength(1e4);
+      expect28(data.body).toHaveLength(1e4);
     });
-    test27("should handle missing content-type header", async (c) => {
+    test28("should handle missing content-type header", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4424,11 +5243,11 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         method: "POST",
         body: "plain text without content-type"
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.bodyText).toBe("plain text without content-type");
+      expect28(data.bodyText).toBe("plain text without content-type");
     });
-    test27("should handle empty request body", async (c) => {
+    test28("should handle empty request body", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4440,9 +5259,9 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: ""
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
     });
-    test27("should handle custom HTTP methods", async (c) => {
+    test28("should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4453,12 +5272,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         });
         if (response.ok) {
           const data = await response.json();
-          expect27(data.method).toBe("CUSTOM");
+          expect28(data.method).toBe("CUSTOM");
         }
       } catch (error) {
       }
     });
-    test27("should handle cookies in headers", async (c) => {
+    test28("should handle cookies in headers", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4468,13 +5287,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
       });
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.headers.cookie).toBe(
+      expect28(data.headers.cookie).toBe(
         "session=abc123; user=test; preferences=dark_mode"
       );
     });
-    test27("should handle URL encoding properly", async (c) => {
+    test28("should handle URL encoding properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4482,13 +5301,13 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const response = await actor.fetch(
         "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
       );
-      expect27(response.ok).toBe(true);
+      expect28(response.ok).toBe(true);
       const data = await response.json();
-      expect27(data.searchParams.special).toBe(" !@#$%^&");
-      expect27(data.searchParams.unicode).toBe("\u2713");
-      expect27(data.searchParams.email).toBe("test@example.com");
+      expect28(data.searchParams.special).toBe(" !@#$%^&");
+      expect28(data.searchParams.unicode).toBe("\u2713");
+      expect28(data.searchParams.email).toBe("test@example.com");
     });
-    test27("should handle concurrent requests maintaining separate contexts", async (c) => {
+    test28("should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -4512,24 +5331,24 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       const results = await Promise.all(
         responses.map((r) => r.json())
       );
-      expect27(results[0].searchParams.id).toBe("1");
-      expect27(results[0].method).toBe("POST");
-      expect27(results[0].body).toEqual({ request: 1 });
-      expect27(results[1].searchParams.id).toBe("2");
-      expect27(results[1].method).toBe("PUT");
-      expect27(results[1].body).toEqual({ request: 2 });
-      expect27(results[2].searchParams.id).toBe("3");
-      expect27(results[2].method).toBe("DELETE");
-      expect27(results[2].body).toBeNull();
+      expect28(results[0].searchParams.id).toBe("1");
+      expect28(results[0].method).toBe("POST");
+      expect28(results[0].body).toEqual({ request: 1 });
+      expect28(results[1].searchParams.id).toBe("2");
+      expect28(results[1].method).toBe("PUT");
+      expect28(results[1].body).toEqual({ request: 2 });
+      expect28(results[2].searchParams.id).toBe("3");
+      expect28(results[2].method).toBe("DELETE");
+      expect28(results[2].body).toBeNull();
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-websocket.ts
-import { describe as describe29, expect as expect28, test as test28 } from "vitest";
+import { describe as describe30, expect as expect29, test as test29 } from "vitest";
 function runRawWebSocketTests(driverTestConfig) {
-  describe29("raw websocket", () => {
-    test28("should establish raw WebSocket connection", async (c) => {
+  describe30("raw websocket", () => {
+    test29("should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["basic"]);
       const ws = await actor.webSocket();
@@ -4556,11 +5375,11 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect28(welcomeMessage.type).toBe("welcome");
-      expect28(welcomeMessage.connectionCount).toBe(1);
+      expect29(welcomeMessage.type).toBe("welcome");
+      expect29(welcomeMessage.connectionCount).toBe(1);
       ws.close();
     });
-    test28("should echo messages", async (c) => {
+    test29("should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["echo"]);
       const ws = await actor.webSocket();
@@ -4588,10 +5407,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect28(echoMessage).toEqual(testMessage);
+      expect29(echoMessage).toEqual(testMessage);
       ws.close();
     });
-    test28("should handle ping/pong protocol", async (c) => {
+    test29("should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["ping"]);
       const ws = await actor.webSocket();
@@ -4617,11 +5436,11 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect28(pongMessage.type).toBe("pong");
-      expect28(pongMessage.timestamp).toBeDefined();
+      expect29(pongMessage.type).toBe("pong");
+      expect29(pongMessage.timestamp).toBeDefined();
       ws.close();
     });
-    test28("should track stats across connections", async (c) => {
+    test29("should track stats across connections", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.webSocket();
@@ -4665,15 +5484,15 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws1.send(JSON.stringify({ type: "getStats" }));
       const stats = await statsPromise;
-      expect28(stats.connectionCount).toBe(2);
-      expect28(stats.messageCount).toBe(4);
+      expect29(stats.connectionCount).toBe(2);
+      expect29(stats.messageCount).toBe(4);
       const actionStats = await actor1.getStats();
-      expect28(actionStats.connectionCount).toBe(2);
-      expect28(actionStats.messageCount).toBe(4);
+      expect29(actionStats.connectionCount).toBe(2);
+      expect29(actionStats.messageCount).toBe(4);
       ws1.close();
       ws2.close();
     });
-    test28("should handle binary data", async (c) => {
+    test29("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketBinaryActor.getOrCreate([
         "binary"
@@ -4706,7 +5525,7 @@ function runRawWebSocketTests(driverTestConfig) {
       const smallData = new Uint8Array([1, 2, 3, 4, 5]);
       ws.send(smallData);
       const smallReversed = await receiveBinaryMessage();
-      expect28(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
+      expect29(Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
       const largeData = new Uint8Array(1024);
       for (let i = 0; i < largeData.length; i++) {
         largeData[i] = i % 256;
@@ -4714,13 +5533,13 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        expect28(largeReversed[i]).toBe(
+        expect29(largeReversed[i]).toBe(
           largeData[largeData.length - 1 - i]
         );
       }
       ws.close();
     });
-    test28("should work with custom paths", async (c) => {
+    test29("should work with custom paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["paths"]);
       const ws = await actor.webSocket("custom/path");
@@ -4740,10 +5559,10 @@ function runRawWebSocketTests(driverTestConfig) {
           { once: true }
         );
       });
-      expect28(welcomeMessage.type).toBe("welcome");
+      expect29(welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    test28("should handle connection close properly", async (c) => {
+    test29("should handle connection close properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate(["close-test"]);
       const ws = await actor.webSocket();
@@ -4756,7 +5575,7 @@ function runRawWebSocketTests(driverTestConfig) {
         });
       }
       const initialStats = await actor.getStats();
-      expect28(initialStats.connectionCount).toBe(1);
+      expect29(initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve) => {
         ws.addEventListener("close", () => resolve(), { once: true });
       });
@@ -4770,9 +5589,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect28(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect29(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test28("should properly handle onWebSocket open and close events", async (c) => {
+    test29("should properly handle onWebSocket open and close events", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate([
         "open-close-test"
@@ -4792,8 +5611,8 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws1.addEventListener("close", reject);
       });
-      expect28(welcome1.type).toBe("welcome");
-      expect28(welcome1.connectionCount).toBe(1);
+      expect29(welcome1.type).toBe("welcome");
+      expect29(welcome1.connectionCount).toBe(1);
       const ws2 = await actor.webSocket();
       await new Promise((resolve, reject) => {
         ws2.addEventListener("open", () => resolve(), { once: true });
@@ -4809,10 +5628,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws2.addEventListener("close", reject);
       });
-      expect28(welcome2.type).toBe("welcome");
-      expect28(welcome2.connectionCount).toBe(2);
+      expect29(welcome2.type).toBe("welcome");
+      expect29(welcome2.connectionCount).toBe(2);
       const midStats = await actor.getStats();
-      expect28(midStats.connectionCount).toBe(2);
+      expect29(midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve) => {
         ws1.addEventListener("close", () => resolve(), { once: true });
@@ -4825,7 +5644,7 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect28(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      expect29(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
       await new Promise((resolve) => {
         ws2.addEventListener("close", () => resolve(), { once: true });
@@ -4838,9 +5657,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve) => setTimeout(resolve, 50));
       }
-      expect28(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect29(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test28("should handle query parameters in websocket paths", async (c) => {
+    test29("should handle query parameters in websocket paths", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate([
         "query-params"
@@ -4863,12 +5682,12 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect28(requestInfo.url).toContain("api/v1/stream");
-      expect28(requestInfo.url).toContain("token=abc123");
-      expect28(requestInfo.url).toContain("user=test");
+      expect29(requestInfo.url).toContain("api/v1/stream");
+      expect29(requestInfo.url).toContain("token=abc123");
+      expect29(requestInfo.url).toContain("user=test");
       ws.close();
     });
-    test28("should handle query parameters on base websocket path (no subpath)", async (c) => {
+    test29("should handle query parameters on base websocket path (no subpath)", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.rawWebSocketActor.getOrCreate([
         "base-path-query-params"
@@ -4878,7 +5697,11 @@ function runRawWebSocketTests(driverTestConfig) {
         ws.addEventListener("open", () => resolve(), { once: true });
         ws.addEventListener("error", reject);
         ws.addEventListener("close", (evt) => {
-          reject(new Error(`WebSocket closed: code=${evt.code} reason=${evt.reason}`));
+          reject(
+            new Error(
+              `WebSocket closed: code=${evt.code} reason=${evt.reason}`
+            )
+          );
         });
       });
       const requestInfoPromise = new Promise((resolve, reject) => {
@@ -4892,18 +5715,237 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws.send(JSON.stringify({ type: "getRequestInfo" }));
       const requestInfo = await requestInfoPromise;
-      expect28(requestInfo.url).toContain("token=secret");
-      expect28(requestInfo.url).toContain("session=123");
+      expect29(requestInfo.url).toContain("token=secret");
+      expect29(requestInfo.url).toContain("session=123");
       ws.close();
     });
   });
 }
 
+// src/driver-test-suite/tests/actor-db-kv-stats.ts
+import { describe as describe31, expect as expect30, test as test30 } from "vitest";
+function runActorDbKvStatsTests(driverTestConfig) {
+  describe31("Actor Database KV Stats Tests", () => {
+    test30(
+      "warm UPDATE uses BATCH_ATOMIC: exactly 1 putBatch, 0 reads, no journal",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-ba-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.increment();
+        const stats = await actor.getStats();
+        const log = await actor.getLog();
+        expect30(stats.putBatchCalls).toBe(1);
+        expect30(stats.getBatchCalls).toBe(0);
+        const allKeys = log.flatMap((e) => e.keys);
+        const journalKeys = allKeys.filter((k) => k.includes("journal"));
+        expect30(journalKeys.length).toBe(0);
+      },
+      3e4
+    );
+    test30(
+      "warm SELECT uses 0 KV round trips",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-2-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.getCount();
+        const stats = await actor.getStats();
+        expect30(stats.getBatchCalls).toBe(0);
+        expect30(stats.putBatchCalls).toBe(0);
+      },
+      3e4
+    );
+    test30(
+      "warm SELECT after UPDATE adds no KV round trips",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-3-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.increment();
+        const updateStats = await actor.getStats();
+        await actor.resetStats();
+        await actor.incrementAndRead();
+        const combinedStats = await actor.getStats();
+        expect30(combinedStats.putBatchCalls).toBe(updateStats.putBatchCalls);
+        expect30(combinedStats.getBatchCalls).toBe(updateStats.getBatchCalls);
+      },
+      3e4
+    );
+    test30(
+      "warm multi-page INSERT writes multiple chunk keys",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-4-${crypto.randomUUID()}`
+        ]);
+        await actor.insertWithIndex();
+        await actor.resetStats();
+        await actor.insertWithIndex();
+        const stats = await actor.getStats();
+        const log = await actor.getLog();
+        expect30(stats.putBatchCalls).toBeGreaterThanOrEqual(1);
+        expect30(stats.putBatchEntries).toBeGreaterThan(1);
+        const putOps = log.filter(
+          (e) => e.op === "putBatch" || e.op === "put"
+        );
+        const allKeys = putOps.flatMap((e) => e.keys);
+        const mainChunkKeys = allKeys.filter(
+          (k) => k.startsWith("chunk:main[")
+        );
+        expect30(mainChunkKeys.length).toBeGreaterThanOrEqual(1);
+      },
+      3e4
+    );
+    test30(
+      "warm ROLLBACK produces no data page writes",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-5-${crypto.randomUUID()}`
+        ]);
+        await actor.rollbackTest();
+        await actor.resetStats();
+        await actor.rollbackTest();
+        const log = await actor.getLog();
+        const putOps = log.filter(
+          (e) => e.op === "putBatch" || e.op === "put"
+        );
+        const mainChunkKeys = putOps.flatMap((e) => e.keys).filter((k) => k.startsWith("chunk:main["));
+        expect30(mainChunkKeys.length).toBe(0);
+      },
+      3e4
+    );
+    test30(
+      "warm multi-statement transaction produces writes",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-6-${crypto.randomUUID()}`
+        ]);
+        await actor.multiStmtTx();
+        await actor.resetStats();
+        await actor.multiStmtTx();
+        const stats = await actor.getStats();
+        expect30(stats.putBatchCalls).toBeGreaterThanOrEqual(1);
+      },
+      3e4
+    );
+    test30(
+      "no WAL or SHM operations occur",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-7-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.increment();
+        const log = await actor.getLog();
+        const allKeys = log.flatMap((e) => e.keys);
+        const walOrShmKeys = allKeys.filter(
+          (k) => k.includes("wal") || k.includes("shm")
+        );
+        expect30(walOrShmKeys.length).toBe(0);
+      },
+      3e4
+    );
+    test30(
+      "every putBatch has at most 128 keys",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-8-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.increment();
+        const log = await actor.getLog();
+        const putBatchOps = log.filter(
+          (e) => e.op === "putBatch"
+        );
+        for (const entry of putBatchOps) {
+          expect30(
+            entry.keys.length
+          ).toBeLessThanOrEqual(128);
+        }
+      },
+      3e4
+    );
+    test30(
+      "large transaction falls back to journal when exceeding 127 dirty pages",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-9-${crypto.randomUUID()}`
+        ]);
+        await actor.warmUp();
+        await actor.bulkInsertLarge();
+        const stats = await actor.getStats();
+        const log = await actor.getLog();
+        expect30(stats.putBatchCalls).toBeGreaterThan(1);
+        const allKeys = log.flatMap((e) => e.keys);
+        const journalKeys = allKeys.filter(
+          (k) => k.includes("journal")
+        );
+        expect30(journalKeys.length).toBeGreaterThan(0);
+        const putBatchOps = log.filter(
+          (e) => e.op === "putBatch"
+        );
+        for (const entry of putBatchOps) {
+          expect30(
+            entry.keys.length
+          ).toBeLessThanOrEqual(128);
+        }
+      },
+      6e4
+    );
+    test30(
+      "large transaction data integrity: 200 rows and integrity check pass",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-10-${crypto.randomUUID()}`
+        ]);
+        await actor.bulkInsertLarge();
+        const count = await actor.getRowCount();
+        expect30(count).toBe(200);
+        const integrity = await actor.runIntegrityCheck();
+        expect30(integrity).toBe("ok");
+      },
+      6e4
+    );
+    test30(
+      "large transaction survives actor sleep and wake",
+      async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor = client.dbKvStatsActor.getOrCreate([
+          `kv-stats-11-${crypto.randomUUID()}`
+        ]);
+        await actor.bulkInsertLarge();
+        const countBefore = await actor.getRowCount();
+        expect30(countBefore).toBe(200);
+        await actor.triggerSleep();
+        await waitFor(driverTestConfig, 250);
+        const countAfter = await actor.getRowCount();
+        expect30(countAfter).toBe(200);
+        const integrity = await actor.runIntegrityCheck();
+        expect30(integrity).toBe("ok");
+      },
+      6e4
+    );
+  });
+}
+
 // src/driver-test-suite/tests/request-access.ts
-import { describe as describe30, expect as expect29, test as test29 } from "vitest";
+import { describe as describe32, expect as expect31, test as test31 } from "vitest";
 function runRequestAccessTests(driverTestConfig) {
-  describe30("Request Access in Lifecycle Hooks", () => {
-    test29("should have access to request object in onBeforeConnect and createConnState", async (c) => {
+  describe32("Request Access in Lifecycle Hooks", () => {
+    test31("should have access to request object in onBeforeConnect and createConnState", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-request"],
@@ -4914,23 +5956,23 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect29(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect29(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
-        expect29(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
-        expect29(
+        expect31(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect31(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect31(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect31(
           requestInfo.onBeforeConnect.requestHeaders
         ).toBeDefined();
-        expect29(requestInfo.createConnState.hasRequest).toBe(true);
-        expect29(requestInfo.createConnState.requestUrl).toBeDefined();
-        expect29(requestInfo.createConnState.requestMethod).toBeDefined();
-        expect29(
+        expect31(requestInfo.createConnState.hasRequest).toBe(true);
+        expect31(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect31(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect31(
           requestInfo.createConnState.requestHeaders
         ).toBeDefined();
       } else {
       }
       await connection.dispose();
     });
-    test29("should not have request when trackRequest is false", async (c) => {
+    test31("should not have request when trackRequest is false", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-no-request"],
@@ -4940,21 +5982,21 @@ function runRequestAccessTests(driverTestConfig) {
       );
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
-      expect29(requestInfo.onBeforeConnect.hasRequest).toBe(false);
-      expect29(requestInfo.onBeforeConnect.requestUrl).toBeNull();
-      expect29(requestInfo.onBeforeConnect.requestMethod).toBeNull();
-      expect29(
+      expect31(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect31(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect31(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect31(
         Object.keys(requestInfo.onBeforeConnect.requestHeaders)
       ).toHaveLength(0);
-      expect29(requestInfo.createConnState.hasRequest).toBe(false);
-      expect29(requestInfo.createConnState.requestUrl).toBeNull();
-      expect29(requestInfo.createConnState.requestMethod).toBeNull();
-      expect29(
+      expect31(requestInfo.createConnState.hasRequest).toBe(false);
+      expect31(requestInfo.createConnState.requestUrl).toBeNull();
+      expect31(requestInfo.createConnState.requestMethod).toBeNull();
+      expect31(
         Object.keys(requestInfo.createConnState.requestHeaders)
       ).toHaveLength(0);
       await connection.dispose();
     });
-    test29("should capture request headers and method", async (c) => {
+    test31("should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-headers"],
@@ -4965,18 +6007,18 @@ function runRequestAccessTests(driverTestConfig) {
       const connection = handle.connect();
       const requestInfo = await connection.getRequestInfo();
       if (driverTestConfig.clientType === "http") {
-        expect29(requestInfo.onBeforeConnect.hasRequest).toBe(true);
-        expect29(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
-        expect29(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
-        expect29(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
-        expect29(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+        expect31(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect31(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
+        expect31(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
+        expect31(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
+        expect31(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
           "object"
         );
-        expect29(requestInfo.createConnState.hasRequest).toBe(true);
-        expect29(requestInfo.createConnState.requestMethod).toBeTruthy();
-        expect29(requestInfo.createConnState.requestUrl).toBeTruthy();
-        expect29(requestInfo.createConnState.requestHeaders).toBeTruthy();
-        expect29(typeof requestInfo.createConnState.requestHeaders).toBe(
+        expect31(requestInfo.createConnState.hasRequest).toBe(true);
+        expect31(requestInfo.createConnState.requestMethod).toBeTruthy();
+        expect31(requestInfo.createConnState.requestUrl).toBeTruthy();
+        expect31(requestInfo.createConnState.requestHeaders).toBeTruthy();
+        expect31(typeof requestInfo.createConnState.requestHeaders).toBe(
           "object"
         );
       } else {
@@ -4988,14 +6030,14 @@ function runRequestAccessTests(driverTestConfig) {
 
 // src/driver-test-suite/mod.ts
 function runDriverTests(driverTestConfigPartial) {
-  describe31("Driver Tests", () => {
+  describe33("Driver Tests", () => {
     var _a;
     const clientTypes = ((_a = driverTestConfigPartial.skip) == null ? void 0 : _a.inline) ? ["http"] : ["http", "inline"];
     for (const clientType of clientTypes) {
-      describe31(`client type (${clientType})`, () => {
+      describe33(`client type (${clientType})`, () => {
         const encodings = ["bare", "cbor", "json"];
         for (const encoding of encodings) {
-          describe31(`encoding (${encoding})`, () => {
+          describe33(`encoding (${encoding})`, () => {
             const driverTestConfig = {
               ...driverTestConfigPartial,
               clientType,
@@ -5019,6 +6061,7 @@ function runDriverTests(driverTestConfigPartial) {
             runActorErrorHandlingTests(driverTestConfig);
             runActorQueueTests(driverTestConfig);
             runActorRunTests(driverTestConfig);
+            runActorSandboxTests(driverTestConfig);
             runActorInlineClientTests(driverTestConfig);
             runActorKvTests(driverTestConfig);
             runActorWorkflowTests(driverTestConfig);
@@ -5027,6 +6070,7 @@ function runDriverTests(driverTestConfigPartial) {
             runRawHttpRequestPropertiesTests(driverTestConfig);
             runRawWebSocketTests(driverTestConfig);
             runActorInspectorTests(driverTestConfig);
+            runActorDbKvStatsTests(driverTestConfig);
           });
         }
       });
@@ -5085,7 +6129,10 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     nodeWebSocket.injectWebSocket(server);
     const address = server.address();
-    invariant2(address && typeof address !== "string", "missing server address");
+    invariant2(
+      address && typeof address !== "string",
+      "missing server address"
+    );
     const port = address.port;
     const serverEndpoint = `http://127.0.0.1:${port}`;
     logger().info({ msg: "test serer listening", port });