rivetkit 2.1.4 → 2.1.6-rc.1

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

@@ -4,43 +4,51 @@
 
 
 
-var _chunkH5TSEPN4cjs = require('../chunk-H5TSEPN4.cjs');
-require('../chunk-GXRVSSVD.cjs');
-require('../chunk-AQD4CBZ2.cjs');
-require('../chunk-HKOSZKKZ.cjs');
-require('../chunk-UWAGLDT6.cjs');
 
 
+var _chunkCMQPDBBRcjs = require('../chunk-CMQPDBBR.cjs');
+require('../chunk-TJ7DKW6F.cjs');
+require('../chunk-VBR35EQF.cjs');
+require('../chunk-IHQAF2HV.cjs');
+require('../chunk-2LY7RW3Y.cjs');
+require('../chunk-JJNZQDUN.cjs');
+require('../chunk-DH6UINWA.cjs');
 
 
+var _chunkYAE3MEJMcjs = require('../chunk-YAE3MEJM.cjs');
 
-var _chunkTEUL4UYNcjs = require('../chunk-TEUL4UYN.cjs');
 
 
-var _chunkQPADHLDUcjs = require('../chunk-QPADHLDU.cjs');
-require('../chunk-6LJAZ5R4.cjs');
-require('../chunk-SR3KQE7Q.cjs');
 
+var _chunkGUHXWPGBcjs = require('../chunk-GUHXWPGB.cjs');
 
 
+var _chunkV3JSZR5Pcjs = require('../chunk-V3JSZR5P.cjs');
+require('../chunk-2ELYUO6C.cjs');
+require('../chunk-SQFCIDCG.cjs');
 
 
+var _chunkCGGGBIDPcjs = require('../chunk-CGGGBIDP.cjs');
 
 
 
 
-var _chunk3B6PCYJBcjs = require('../chunk-3B6PCYJB.cjs');
+
+
+
+
+var _chunkHNE2AK6Ccjs = require('../chunk-HNE2AK6C.cjs');
 require('../chunk-NIYZDWMW.cjs');
 
 
-var _chunkLK36OGGOcjs = require('../chunk-LK36OGGO.cjs');
+var _chunkA4KEUCB6cjs = require('../chunk-A4KEUCB6.cjs');
 
 
-var _chunk4KSHPFXFcjs = require('../chunk-4KSHPFXF.cjs');
+var _chunkMPLMTJY5cjs = require('../chunk-MPLMTJY5.cjs');
 
 
 
-var _chunkL47L3ZWJcjs = require('../chunk-L47L3ZWJ.cjs');
+var _chunk6G7ZNM27cjs = require('../chunk-6G7ZNM27.cjs');
 require('../chunk-HDQ2JUQT.cjs');
 
 // src/driver-test-suite/mod.ts
@@ -85,20 +93,20 @@ function createTestInlineClientDriver(endpoint, encoding) {
       const oldUrl = new URL(actorRequest.url);
       const normalizedPath = oldUrl.pathname.startsWith("/") ? oldUrl.pathname.slice(1) : oldUrl.pathname;
       const pathWithQuery = normalizedPath + oldUrl.search;
-      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
+      _chunkCMQPDBBRcjs.logger.call(void 0, ).debug({
         msg: "sending raw http request via test inline driver",
         actorId,
         encoding,
         path: pathWithQuery
       });
       const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
-      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
+      _chunkCMQPDBBRcjs.logger.call(void 0, ).debug({
         msg: "rewriting http url",
         from: oldUrl,
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunk3B6PCYJBcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkHNE2AK6Ccjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -114,7 +122,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkTEUL4UYNcjs.ActorError)(
+              throw new (0, _chunkGUHXWPGBcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -122,7 +130,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkTEUL4UYNcjs.ActorError)) {
+          if (!(e instanceof _chunkGUHXWPGBcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -131,33 +139,33 @@ function createTestInlineClientDriver(endpoint, encoding) {
       return response;
     },
     async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkQPADHLDUcjs.importWebSocket.call(void 0, );
+      const WebSocket2 = await _chunkV3JSZR5Pcjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
+      _chunkCMQPDBBRcjs.logger.call(void 0, ).debug({
         msg: "creating websocket connection via test inline driver",
         url: wsUrl.toString()
       });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       const protocols = [];
-      protocols.push(_chunk3B6PCYJBcjs.WS_PROTOCOL_STANDARD);
-      protocols.push(`${_chunk3B6PCYJBcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(_chunkHNE2AK6Ccjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunkHNE2AK6Ccjs.WS_PROTOCOL_TARGET}actor`);
       protocols.push(
-        `${_chunk3B6PCYJBcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
+        `${_chunkHNE2AK6Ccjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`
       );
-      protocols.push(`${_chunk3B6PCYJBcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkHNE2AK6Ccjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunk3B6PCYJBcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunkHNE2AK6Ccjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunk3B6PCYJBcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunkHNE2AK6Ccjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
-      _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
+      _chunkCMQPDBBRcjs.logger.call(void 0, ).debug({
         msg: "connecting to websocket",
         url: finalWsUrl,
         protocols
@@ -177,7 +185,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
         encoding2,
         params
       );
-      return upgradeWebSocket(() => wsHandler)(c, _chunk4KSHPFXFcjs.noopNext.call(void 0, ));
+      return upgradeWebSocket(() => wsHandler)(c, _chunkMPLMTJY5cjs.noopNext.call(void 0, ));
     },
     async buildGatewayUrl(actorId) {
       return `${endpoint}/gateway/${actorId}`;
@@ -194,7 +202,7 @@ function createTestInlineClientDriver(endpoint, encoding) {
   };
 }
 async function makeInlineRequest(endpoint, encoding, method, args) {
-  _chunkH5TSEPN4cjs.logger.call(void 0, ).debug({
+  _chunkCMQPDBBRcjs.logger.call(void 0, ).debug({
     msg: "sending inline request",
     encoding,
     method,
@@ -224,14 +232,14 @@ async function makeInlineRequest(endpoint, encoding, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkTEUL4UYNcjs.ActorError)(
+    throw new (0, _chunkGUHXWPGBcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkLK36OGGOcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkA4KEUCB6cjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -245,7 +253,7 @@ async function setupDriverTest(c, driverTestConfig) {
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkTEUL4UYNcjs.createClient.call(void 0, {
+    client = _chunkYAE3MEJMcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
@@ -258,18 +266,18 @@ async function setupDriverTest(c, driverTestConfig) {
   } else if (driverTestConfig.clientType === "inline") {
     const encoding = _nullishCoalesce(driverTestConfig.encoding, () => ( "bare"));
     const managerDriver = createTestInlineClientDriver(endpoint, encoding);
-    const runConfig = _chunkTEUL4UYNcjs.ClientConfigSchema.parse({
+    const runConfig = _chunkGUHXWPGBcjs.ClientConfigSchema.parse({
       encoding
     });
-    client = _chunkTEUL4UYNcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunkGUHXWPGBcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkLK36OGGOcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkA4KEUCB6cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   c.onTestFinished(async () => {
     if (!driverTestConfig.HACK_skipCleanupNet) {
       await client.dispose();
     }
-    _chunkH5TSEPN4cjs.logger.call(void 0, ).info("cleaning up test");
+    _chunkCMQPDBBRcjs.logger.call(void 0, ).info("cleaning up test");
     await cleanup();
   });
   return {
@@ -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 });
         _vitest.expect.call(void 0, result.itemCount).toBe(800);
-        _vitest.expect.call(void 0, result.firstItem).toBe("Item 0 with some additional text to increase size");
-        _vitest.expect.call(void 0, result.lastItem).toBe("Item 799 with some additional text to increase size");
+        _vitest.expect.call(void 0, result.firstItem).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        _vitest.expect.call(void 0, result.lastItem).toBe(
+          "Item 799 with some additional text to increase size"
+        );
       });
       _vitest.test.call(void 0, "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 _vitest.expect.call(void 0, 
           instance.processLargeRequest({ items })
@@ -395,8 +411,12 @@ function runActionFeaturesTests(driverTestConfig) {
         const instance = client.largePayloadActor.getOrCreate();
         const result = await instance.getLargeResponse(800);
         _vitest.expect.call(void 0, result.items).toHaveLength(800);
-        _vitest.expect.call(void 0, result.items[0]).toBe("Item 0 with some additional text to increase size");
-        _vitest.expect.call(void 0, result.items[799]).toBe("Item 799 with some additional text to increase size");
+        _vitest.expect.call(void 0, result.items[0]).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        _vitest.expect.call(void 0, result.items[799]).toBe(
+          "Item 799 with some additional text to increase size"
+        );
       });
       _vitest.test.call(void 0, "should reject response exceeding maxOutgoingMessageSize", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -421,7 +441,9 @@ function runAccessControlTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, 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");
       _vitest.expect.call(void 0, await eventPromise).toEqual({ value: "wildcard" });
@@ -745,6 +772,65 @@ function runActorConnTests(driverTestConfig) {
         await conn1.dispose();
         await conn2.dispose();
       });
+      _vitest.test.call(void 0, "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();
+        _vitest.expect.call(void 0, initializers).toEqual(["user1", "user2"]);
+        _vitest.expect.call(void 0, connectionCount).toBe(2);
+        await conn2.dispose();
+      });
+      _vitest.test.call(void 0, "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 _vitest.expect.call(void 0, conn.getInitializers()).rejects.toMatchObject({
+          group: "client",
+          code: "get_params_failed"
+        });
+        await _vitest.vi.waitFor(
+          async () => {
+            _vitest.expect.call(void 0, await conn.getInitializers()).toEqual(["user1"]);
+          },
+          { timeout: 1e4 }
+        );
+        _vitest.expect.call(void 0, receivedErrors).toEqual([
+          { group: "client", code: "get_params_failed" }
+        ]);
+        _vitest.expect.call(void 0, attempts).toBeGreaterThanOrEqual(2);
+        await conn.dispose();
+      });
     });
     _vitest.describe.call(void 0, "Lifecycle Hooks", () => {
       _vitest.test.call(void 0, "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 });
         _vitest.expect.call(void 0, result.itemCount).toBe(800);
-        _vitest.expect.call(void 0, result.firstItem).toBe("Item 0 with some additional text to increase size");
-        _vitest.expect.call(void 0, result.lastItem).toBe("Item 799 with some additional text to increase size");
+        _vitest.expect.call(void 0, result.firstItem).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        _vitest.expect.call(void 0, result.lastItem).toBe(
+          "Item 799 with some additional text to increase size"
+        );
         const lastRequestSize = await connection.getLastRequestSize();
         _vitest.expect.call(void 0, 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 _vitest.expect.call(void 0, 
           connection.processLargeRequest({ items })
@@ -955,8 +1049,12 @@ function runActorConnTests(driverTestConfig) {
         const connection = handle.connect();
         const result = await connection.getLargeResponse(800);
         _vitest.expect.call(void 0, result.items).toHaveLength(800);
-        _vitest.expect.call(void 0, result.items[0]).toBe("Item 0 with some additional text to increase size");
-        _vitest.expect.call(void 0, result.items[799]).toBe("Item 799 with some additional text to increase size");
+        _vitest.expect.call(void 0, result.items[0]).toBe(
+          "Item 0 with some additional text to increase size"
+        );
+        _vitest.expect.call(void 0, result.items[799]).toBe(
+          "Item 799 with some additional text to increase size"
+        );
         await connection.dispose();
       });
       _vitest.test.call(void 0, "should reject response exceeding maxOutgoingMessageSize", async (c) => {
@@ -989,7 +1087,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkCMQPDBBRcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const ping2 = await hibernatingActor.ping();
         _vitest.expect.call(void 0, ping2).toBe("pong");
@@ -1011,7 +1109,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await hibernatingActor.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkCMQPDBBRcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         const count3 = await hibernatingActor.getConnCount();
         _vitest.expect.call(void 0, count3).toBe(2);
@@ -1033,7 +1131,7 @@ function runActorConnHibernationTests(driverTestConfig) {
         await conn1.triggerSleep();
         await waitFor(
           driverTestConfig,
-          _chunkH5TSEPN4cjs.HIBERNATION_SLEEP_TIMEOUT + 100
+          _chunkCMQPDBBRcjs.HIBERNATION_SLEEP_TIMEOUT + 100
         );
         await conn1.dispose();
         await waitFor(driverTestConfig, 250);
@@ -1279,7 +1377,10 @@ function runActorDbTests(driverTestConfig) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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();
           _vitest.expect.call(void 0, values.length).toBeGreaterThanOrEqual(2);
-          _vitest.expect.call(void 0, values.some((row) => row.value === "alpha")).toBeTruthy();
-          _vitest.expect.call(void 0, values.some((row) => row.value === "beta")).toBeTruthy();
+          _vitest.expect.call(void 0, 
+            values.some((row) => row.value === "alpha")
+          ).toBeTruthy();
+          _vitest.expect.call(void 0, 
+            values.some((row) => row.value === "beta")
+          ).toBeTruthy();
           await actor.updateValue(first.id, "alpha-updated");
           const updated = await actor.getValue(first.id);
           _vitest.expect.call(void 0, updated).toBe("alpha-updated");
@@ -1326,7 +1434,10 @@ function runActorDbTests(driverTestConfig) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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) {
       _vitest.test.call(void 0, 
         "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
           );
-          _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe(
+            "ok"
+          );
           await actor.triggerSleep();
           await waitFor(driverTestConfig, SLEEP_WAIT_MS + 100);
-          _vitest.expect.call(void 0, (await actor.integrityCheck()).toLowerCase()).toBe("ok");
+          _vitest.expect.call(void 0, (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) {
         }
         _vitest.expect.call(void 0, after.create).toBeGreaterThanOrEqual(before.create);
         _vitest.expect.call(void 0, after.migrate).toBeGreaterThanOrEqual(before.migrate);
-        _vitest.expect.call(void 0, after.cleanup).toBeGreaterThanOrEqual(before.cleanup + 1);
+        _vitest.expect.call(void 0, 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);
         }
-        _vitest.expect.call(void 0, cleanupCount).toBeGreaterThanOrEqual(beforeTotalCleanup + 1);
+        _vitest.expect.call(void 0, 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) {
-          _vitest.expect.call(void 0, _nullishCoalesce(lifecycleCleanup.get(actorId), () => ( 0))).toBeGreaterThanOrEqual(1);
+          _vitest.expect.call(void 0, 
+            _nullishCoalesce(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) {
           _vitest.expect.call(void 0, err.group).toBe("actor");
           _vitest.expect.call(void 0, err.code).toBe("not_found");
         }
-        _vitest.expect.call(void 0, destroyed, `actor ${id} should be destroyed`).toBe(
-          true
-        );
+        _vitest.expect.call(void 0, destroyed, `actor ${id} should be destroyed`).toBe(true);
       }
     });
     _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, result).toBe("pong");
       await newActor.destroy();
@@ -2014,10 +2171,7 @@ function runActorScheduleTests(driverTestConfig) {
           _vitest.expect.call(void 0, history1[0]).toBe("first");
           await waitFor(driverTestConfig, 500);
           const history2 = await scheduled.getTaskHistory();
-          _vitest.expect.call(void 0, history2.slice(0, 2)).toEqual([
-            "first",
-            "second"
-          ]);
+          _vitest.expect.call(void 0, history2.slice(0, 2)).toEqual(["first", "second"]);
           await waitFor(driverTestConfig, 500);
           const history3 = await scheduled.getTaskHistory();
           _vitest.expect.call(void 0, history3).toEqual(["first", "second", "third"]);
@@ -2058,7 +2212,7 @@ function runActorSleepTests(driverTestConfig) {
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -2074,7 +2228,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2090,7 +2244,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -2098,6 +2252,28 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(2);
       }
     });
+    _vitest.test.call(void 0, "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);
+      _vitest.expect.call(void 0, receivedMessages).toHaveLength(1);
+      _vitest.expect.call(void 0, (_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();
+        _vitest.expect.call(void 0, waitUntilMessageCount).toBe(1);
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
     _vitest.test.call(void 0, "rpc calls keep actor awake", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const sleepActor = client.sleep.getOrCreate();
@@ -2106,19 +2282,19 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT - 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2133,8 +2309,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunkH5TSEPN4cjs.SLEEP_TIMEOUT - 250);
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await sleepActor.setAlarm(_chunkCMQPDBBRcjs.SLEEP_TIMEOUT - 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
@@ -2149,8 +2325,8 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await sleepActor.setAlarm(_chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 200);
+      await sleepActor.setAlarm(_chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 200);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2170,7 +2346,7 @@ function runActorSleepTests(driverTestConfig) {
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       await sleepActor.finishLongRunningRpc();
       await longRunningPromise;
       {
@@ -2179,7 +2355,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       await sleepActor.dispose();
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
@@ -2211,7 +2387,7 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       ws.send(JSON.stringify({ type: "getCounts" }));
       const counts = await new Promise((resolve) => {
         ws.onmessage = (event) => {
@@ -2224,7 +2400,7 @@ function runActorSleepTests(driverTestConfig) {
       _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
       _vitest.expect.call(void 0, counts.startCount).toBe(1);
       ws.close();
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2242,7 +2418,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      const fetchDuration = _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250;
+      const fetchDuration = _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250;
       const fetchPromise = sleepActor.fetch(
         `long-request?duration=${fetchDuration}`
       );
@@ -2255,7 +2431,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
         _vitest.expect.call(void 0, requestCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(1);
@@ -2270,19 +2446,77 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.SLEEP_TIMEOUT + 250);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
         _vitest.expect.call(void 0, sleepCount).toBe(0);
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
     });
+    _vitest.test.call(void 0, "preventSleep blocks auto sleep until cleared", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(0);
+        _vitest.expect.call(void 0, status.startCount).toBe(1);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(false);
+        _vitest.expect.call(void 0, status.preventSleepOnWake).toBe(false);
+      }
+      _vitest.expect.call(void 0, await sleepActor.setPreventSleep(true)).toBe(true);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(0);
+        _vitest.expect.call(void 0, status.startCount).toBe(1);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(true);
+      }
+      _vitest.expect.call(void 0, await sleepActor.setPreventSleep(false)).toBe(false);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(1);
+        _vitest.expect.call(void 0, status.startCount).toBe(2);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(false);
+      }
+    });
+    _vitest.test.call(void 0, "preventSleep can be restored during onWake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithPreventSleep.getOrCreate();
+      _vitest.expect.call(void 0, await sleepActor.setPreventSleepOnWake(true)).toBe(true);
+      await sleepActor.triggerSleep();
+      await waitFor(driverTestConfig, 250);
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(1);
+        _vitest.expect.call(void 0, status.startCount).toBe(2);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(true);
+        _vitest.expect.call(void 0, status.preventSleepOnWake).toBe(true);
+      }
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(1);
+        _vitest.expect.call(void 0, status.startCount).toBe(2);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(true);
+      }
+      _vitest.expect.call(void 0, await sleepActor.setPreventSleepOnWake(false)).toBe(false);
+      _vitest.expect.call(void 0, await sleepActor.setPreventSleep(false)).toBe(false);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.SLEEP_TIMEOUT + 250);
+      {
+        const status = await sleepActor.getStatus();
+        _vitest.expect.call(void 0, status.sleepCount).toBe(2);
+        _vitest.expect.call(void 0, status.startCount).toBe(3);
+        _vitest.expect.call(void 0, status.preventSleep).toBe(false);
+        _vitest.expect.call(void 0, status.preventSleepOnWake).toBe(false);
+      }
+    });
   });
 }
 
@@ -2373,8 +2607,8 @@ function runActorErrorHandlingTests(driverTestConfig) {
           await handle.throwInternalError();
           _vitest.expect.call(void 0, true).toBe(false);
         } catch (error) {
-          _vitest.expect.call(void 0, error.code).toBe(_chunkL47L3ZWJcjs.INTERNAL_ERROR_CODE);
-          _vitest.expect.call(void 0, error.message).toBe(_chunkL47L3ZWJcjs.INTERNAL_ERROR_DESCRIPTION);
+          _vitest.expect.call(void 0, error.code).toBe(_chunk6G7ZNM27cjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunk6G7ZNM27cjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -2745,26 +2979,24 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.expect.call(void 0, response.status).toBe(200);
       const data = await response.json();
-      _vitest.expect.call(void 0, data).toEqual({ state: { count: 5 } });
+      _vitest.expect.call(void 0, data).toEqual({
+        state: { count: 5 },
+        isStateEnabled: true
+      });
     });
     _vitest.test.call(void 0, "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 } })
+      });
       _vitest.expect.call(void 0, patchResponse.status).toBe(200);
       const patchData = await patchResponse.json();
       _vitest.expect.call(void 0, patchData).toEqual({ ok: true });
@@ -2806,9 +3038,7 @@ function runActorInspectorTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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) {
     });
     _vitest.test.call(void 0, "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) {
     });
     _vitest.test.call(void 0, "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) {
       _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(false);
       _vitest.expect.call(void 0, data.history).toBeNull();
     });
-    _vitest.test.call(void 0, "GET /inspector/summary returns full actor snapshot", async (c) => {
+    _vitest.test.call(void 0, "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" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, Array.isArray(data.schema.tables)).toBe(true);
+      const testDataTable = data.schema.tables.find(
+        (table) => table.table.name === "test_data"
+      );
+      _vitest.expect.call(void 0, testDataTable).toBeDefined();
+      _vitest.expect.call(void 0, testDataTable == null ? void 0 : testDataTable.table.schema).toBe("main");
+      _vitest.expect.call(void 0, testDataTable == null ? void 0 : testDataTable.table.type).toBe("table");
+      _vitest.expect.call(void 0, testDataTable == null ? void 0 : testDataTable.records).toBe(2);
+      _vitest.expect.call(void 0, testDataTable == null ? void 0 : testDataTable.columns.map((column) => column.name)).toEqual(
+        ["id", "value", "payload", "created_at"]
+      );
+    });
+    _vitest.test.call(void 0, "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();
+      }
+      _vitest.expect.call(void 0, state.runCount).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, state.history.length).toBeGreaterThan(0);
+      const gatewayUrl = await handle.getGatewayUrl();
+      const response = await fetch(
+        `${gatewayUrl}/inspector/workflow-history`,
+        {
+          headers: { Authorization: "Bearer token" }
+        }
+      );
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(true);
+      _vitest.expect.call(void 0, data.history).not.toBeNull();
+      _vitest.expect.call(void 0, (_a = data.history) == null ? void 0 : _a.nameRegistry.length).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, (_b = data.history) == null ? void 0 : _b.entries.length).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, 
+        Object.keys(_nullishCoalesce(((_c = data.history) == null ? void 0 : _c.entryMetadata), () => ( {}))).length
+      ).toBeGreaterThan(0);
+    });
+    _vitest.test.call(void 0, "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" }
         }
       );
       _vitest.expect.call(void 0, response.status).toBe(200);
       const data = await response.json();
+      _vitest.expect.call(void 0, data.rows).toHaveLength(1);
+      _vitest.expect.call(void 0, (_a = data.rows[0]) == null ? void 0 : _a.id).toBe(2);
+      _vitest.expect.call(void 0, (_b = data.rows[0]) == null ? void 0 : _b.value).toBe("Bob");
+      _vitest.expect.call(void 0, (_c = data.rows[0]) == null ? void 0 : _c.payload).toBe("");
+      _vitest.expect.call(void 0, typeof ((_d = data.rows[0]) == null ? void 0 : _d.created_at)).toBe("number");
+    });
+    _vitest.test.call(void 0, "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" }
+      });
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
       _vitest.expect.call(void 0, data.state).toEqual({ count: 7 });
       _vitest.expect.call(void 0, Array.isArray(data.connections)).toBe(true);
       _vitest.expect.call(void 0, data.rpcs).toContain("increment");
@@ -2913,11 +3215,34 @@ function runActorInspectorTests(driverTestConfig) {
       _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(false);
       _vitest.expect.call(void 0, data.workflowHistory).toBeNull();
     });
-    _vitest.test.call(void 0, "inspector endpoints require auth in non-dev mode", async (c) => {
+    _vitest.test.call(void 0, "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" }
+      });
+      _vitest.expect.call(void 0, response.status).toBe(200);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.isWorkflowEnabled).toBe(true);
+      _vitest.expect.call(void 0, data.workflowHistory).not.toBeNull();
+      _vitest.expect.call(void 0, (_a = data.workflowHistory) == null ? void 0 : _a.nameRegistry.length).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, (_b = data.workflowHistory) == null ? void 0 : _b.entries.length).toBeGreaterThan(0);
+      _vitest.expect.call(void 0, 
+        Object.keys(_nullishCoalesce(((_c = data.workflowHistory) == null ? void 0 : _c.entryMetadata), () => ( {}))).length
+      ).toBeGreaterThan(0);
+    });
+    _vitest.test.call(void 0, "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");
       _vitest.expect.call(void 0, value).toBe("hello");
@@ -2951,44 +3278,70 @@ function runActorKvTests(driverTestConfig) {
         { key: "prefix-b", value: "beta" }
       ]);
     });
-    _vitest.test.call(void 0, 
-      "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
-        ]);
-        _vitest.expect.call(void 0, values).toEqual([4, 8, 15, 16, 23, 42]);
-      }
-    );
-  });
-}
-
-// src/driver-test-suite/tests/actor-metadata.ts
-
-function runActorMetadataTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "Actor Metadata Tests", () => {
-    _vitest.describe.call(void 0, "Actor Name", () => {
-      _vitest.test.call(void 0, "should provide access to actor name", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.metadataActor.getOrCreate();
-        const actorName = await handle.getActorName();
-        _vitest.expect.call(void 0, actorName).toBe("metadataActor");
-      });
-      _vitest.test.call(void 0, "should preserve actor name in state during onWake", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
+    _vitest.test.call(void 0, "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");
+      _vitest.expect.call(void 0, range).toEqual([
+        { key: "b", value: "bravo" },
+        { key: "c", value: "charlie" }
+      ]);
+      const reversed = await kvHandle.listTextRange("a", "d", {
+        reverse: true,
+        limit: 2
+      });
+      _vitest.expect.call(void 0, reversed).toEqual([
+        { key: "c", value: "charlie" },
+        { key: "b", value: "bravo" }
+      ]);
+      await kvHandle.deleteTextRange("b", "d");
+      const remaining = await kvHandle.listText("");
+      _vitest.expect.call(void 0, remaining).toEqual([
+        { key: "a", value: "alpha" },
+        { key: "d", value: "delta" }
+      ]);
+    });
+    _vitest.test.call(void 0, "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]
+      );
+      _vitest.expect.call(void 0, values).toEqual([4, 8, 15, 16, 23, 42]);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-metadata.ts
+
+function runActorMetadataTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Metadata Tests", () => {
+    _vitest.describe.call(void 0, "Actor Name", () => {
+      _vitest.test.call(void 0, "should provide access to actor name", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const actorName = await handle.getActorName();
+        _vitest.expect.call(void 0, actorName).toBe("metadataActor");
+      });
+      _vitest.test.call(void 0, "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();
         _vitest.expect.call(void 0, storedName).toBe("metadataActor");
@@ -3110,6 +3463,49 @@ function runActorOnStateChangeTests(driverTestConfig) {
 
 function runActorQueueTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor Queue Tests", () => {
+    async function expectManyQueueChildToDrain(handle, key) {
+      const child = handle.getOrCreate([key]);
+      const conn = child.connect();
+      const messageCount = _chunkCMQPDBBRcjs.MANY_QUEUE_NAMES.length * 4;
+      try {
+        _vitest.expect.call(void 0, await conn.ping()).toEqual(
+          _vitest.expect.objectContaining({
+            pong: true
+          })
+        );
+        await Promise.all(
+          Array.from(
+            { length: messageCount },
+            (_, index) => child.send(
+              _chunkCMQPDBBRcjs.MANY_QUEUE_NAMES[index % _chunkCMQPDBBRcjs.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();
+        }
+        _vitest.expect.call(void 0, snapshot.started).toBe(true);
+        _vitest.expect.call(void 0, snapshot.processed).toHaveLength(messageCount);
+        _vitest.expect.call(void 0, new Set(snapshot.processed)).toEqual(
+          new Set(_chunkCMQPDBBRcjs.MANY_QUEUE_NAMES)
+        );
+        _vitest.expect.call(void 0, 
+          await child.send(
+            _chunkCMQPDBBRcjs.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);
+      }
+    }
     _vitest.test.call(void 0, "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;
       _vitest.expect.call(void 0, result.status).toBe("timedOut");
     });
+    _vitest.test.call(void 0, 
+      "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"
+        ]);
+        _vitest.expect.call(void 0, await parent.spawnChild("many-action-child")).toEqual({
+          key: "many-action-child"
+        });
+        await expectManyQueueChildToDrain(
+          client.manyQueueChildActor,
+          "many-action-child"
+        );
+      }
+    );
+    _vitest.test.call(void 0, 
+      "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"
+        ]);
+        _vitest.expect.call(void 0, 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();
+        }
+        _vitest.expect.call(void 0, spawned).toContain("many-run-child");
+        await expectManyQueueChildToDrain(
+          client.manyQueueChildActor,
+          "many-run-child"
+        );
+      }
+    );
     _vitest.test.call(void 0, "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");
       _vitest.expect.call(void 0, first).toEqual({ name: "tasks", body: { value: 789 } });
-      const retried = await handle.receiveOne("tasks", { timeout: 1e3 });
+      const retried = await handle.receiveOne("tasks", {
+        timeout: 1e3
+      });
       _vitest.expect.call(void 0, retried).toEqual({ name: "tasks", body: { value: 789 } });
     });
     _vitest.test.call(void 0, "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");
       _vitest.expect.call(void 0, result).toEqual({
         group: "queue",
         code: "previous_message_not_completed"
@@ -3331,9 +3765,7 @@ function runActorQueueTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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");
       _vitest.expect.call(void 0, result).toEqual({
@@ -3398,14 +3830,12 @@ function runActorRunTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
       const tickCount1 = state1.tickCount;
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 300);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.RUN_SLEEP_TIMEOUT + 300);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.runStarted).toBe(true);
       _vitest.expect.call(void 0, state2.runExited).toBe(false);
@@ -3418,7 +3848,7 @@ function runActorRunTests(driverTestConfig) {
       ]);
       const state = await actor.getState();
       _vitest.expect.call(void 0, state.wakeCount).toBe(1);
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 300);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.RUN_SLEEP_TIMEOUT + 300);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.wakeCount).toBe(2);
     });
@@ -3456,37 +3886,121 @@ function runActorRunTests(driverTestConfig) {
       await waitFor(driverTestConfig, 100);
       const state1 = await actor.getState();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, _chunkH5TSEPN4cjs.RUN_SLEEP_TIMEOUT + 500);
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.RUN_SLEEP_TIMEOUT + 500);
       const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.wakeCount).toBeGreaterThan(state1.wakeCount);
     });
-    _vitest.test.call(void 0, "run handler that exits early triggers destroy", async (c) => {
+    _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, 300);
-      const actor2 = client.runWithEarlyExit.getOrCreate([
-        "early-exit-fresh"
-      ]);
-      const state2 = await actor2.getState();
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.RUN_SLEEP_TIMEOUT + 400);
+      const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.runStarted).toBe(true);
+      _vitest.expect.call(void 0, state2.destroyCalled).toBe(false);
+      if ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sleep) {
+        _vitest.expect.call(void 0, state2.sleepCount).toBe(0);
+        _vitest.expect.call(void 0, state2.wakeCount).toBe(1);
+      } else {
+        _vitest.expect.call(void 0, state2.sleepCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state2.wakeCount).toBeGreaterThan(1);
+      }
     });
-    _vitest.test.call(void 0, "run handler that throws error triggers destroy", async (c) => {
+    _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, state1.runStarted).toBe(true);
-      await waitFor(driverTestConfig, 300);
-      const actor2 = client.runWithError.getOrCreate(["run-error-fresh"]);
-      const state2 = await actor2.getState();
+      await waitFor(driverTestConfig, _chunkCMQPDBBRcjs.RUN_SLEEP_TIMEOUT + 400);
+      const state2 = await actor.getState();
       _vitest.expect.call(void 0, state2.runStarted).toBe(true);
+      _vitest.expect.call(void 0, state2.destroyCalled).toBe(false);
+      if ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sleep) {
+        _vitest.expect.call(void 0, state2.sleepCount).toBe(0);
+        _vitest.expect.call(void 0, state2.wakeCount).toBe(1);
+      } else {
+        _vitest.expect.call(void 0, state2.sleepCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state2.wakeCount).toBeGreaterThan(1);
+      }
     });
   });
 }
 
+// src/driver-test-suite/tests/actor-sandbox.ts
+
+function runActorSandboxTests(driverTestConfig) {
+  var _a;
+  _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sandbox)("Actor Sandbox Tests", () => {
+    _vitest.test.call(void 0, "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 _vitest.vi.waitFor(
+        async () => {
+          return await sandbox.getHealth();
+        },
+        {
+          timeout: 12e4,
+          interval: 500
+        }
+      );
+      _vitest.expect.call(void 0, typeof health.status).toBe("string");
+      const { url } = await sandbox.getSandboxUrl();
+      _vitest.expect.call(void 0, url).toMatch(/^https?:\/\//);
+      await sandbox.mkdirFs({ path: "/root/tmp" });
+      await sandbox.writeFsFile(
+        { path: "/root/tmp/hello.txt" },
+        "sandbox actor driver test"
+      );
+      _vitest.expect.call(void 0, 
+        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" });
+      _vitest.expect.call(void 0, stat.entryType).toBe("file");
+      await sandbox.moveFs({
+        from: "/root/tmp/hello.txt",
+        to: "/root/tmp/renamed.txt"
+      });
+      _vitest.expect.call(void 0, 
+        (await sandbox.listFsEntries({ path: "/root/tmp" })).map(
+          (entry) => entry.name
+        )
+      ).toContain("renamed.txt");
+      await sandbox.dispose();
+      const healthAfterDispose = await _vitest.vi.waitFor(
+        async () => {
+          return await sandbox.getHealth();
+        },
+        {
+          timeout: 12e4,
+          interval: 500
+        }
+      );
+      _vitest.expect.call(void 0, typeof healthAfterDispose.status).toBe("string");
+      _vitest.expect.call(void 0, 
+        decoder.decode(
+          await sandbox.readFsFile({ path: "/root/tmp/renamed.txt" })
+        )
+      ).toBe("sandbox actor driver test");
+      await sandbox.deleteFsEntry({ path: "/root/tmp", recursive: true });
+      _vitest.expect.call(void 0, await sandbox.listFsEntries({ path: "/root" })).not.toEqual(
+        _vitest.expect.arrayContaining([
+          _vitest.expect.objectContaining({ name: "tmp" })
+        ])
+      );
+    }, 18e4);
+  });
+}
+
 // src/driver-test-suite/tests/actor-stateless.ts
 
 function runActorStatelessTests(driverTestConfig) {
@@ -3606,7 +4120,7 @@ function runActorVarsTests(driverTestConfig) {
 
 function runActorWorkflowTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor Workflow Tests", () => {
-    var _a;
+    var _a, _b, _c, _d;
     _vitest.test.call(void 0, "replays steps and guards state access", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowCounterActor.getOrCreate([
@@ -3626,8 +4140,10 @@ function runActorWorkflowTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "consumes queue messages via workflow queue.next", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
-      const actor = client.workflowQueueActor.getOrCreate(["workflow-queue"]);
-      await actor.send(_chunkH5TSEPN4cjs.WORKFLOW_QUEUE_NAME, {
+      const actor = client.workflowQueueActor.getOrCreate([
+        "workflow-queue"
+      ]);
+      await actor.send(_chunkCMQPDBBRcjs.WORKFLOW_QUEUE_NAME, {
         hello: "world"
       });
       await waitFor(driverTestConfig, 200);
@@ -3645,6 +4161,118 @@ function runActorWorkflowTests(driverTestConfig) {
         response: { echo: { value: 123 } }
       });
     });
+    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"]
+      }
+    ]) {
+      _vitest.test.call(void 0, 
+        `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(
+            _chunkCMQPDBBRcjs.WORKFLOW_NESTED_QUEUE_NAME,
+            {
+              items: testCase.firstItems
+            },
+            {
+              wait: true,
+              timeout: 1e3
+            }
+          );
+          _vitest.expect.call(void 0, first).toEqual({
+            status: "completed",
+            response: {
+              processed: testCase.firstItems.length
+            }
+          });
+          const second = await actor.send(
+            _chunkCMQPDBBRcjs.WORKFLOW_NESTED_QUEUE_NAME,
+            {
+              items: testCase.secondItems
+            },
+            {
+              wait: true,
+              timeout: 1e3
+            }
+          );
+          _vitest.expect.call(void 0, second).toEqual({
+            status: "completed",
+            response: {
+              processed: testCase.secondItems.length
+            }
+          });
+          const state = await actor.getState();
+          _vitest.expect.call(void 0, state.processed).toEqual(testCase.expected);
+        }
+      );
+    }
+    _vitest.test.call(void 0, 
+      "starts child workflows created inside workflow steps",
+      async (c) => {
+        const { client } = await setupDriverTest(
+          c,
+          driverTestConfig
+        );
+        const parent = client.workflowSpawnParentActor.getOrCreate([
+          "workflow-spawn-parent"
+        ]);
+        _vitest.expect.call(void 0, 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();
+        }
+        _vitest.expect.call(void 0, 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();
+        _vitest.expect.call(void 0, childState).toEqual({
+          label: "child-1",
+          started: true,
+          processed: ["hello"]
+        });
+      }
+    );
     _vitest.test.call(void 0, "db and client are step-only in workflow context", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor = client.workflowAccessActor.getOrCreate([
@@ -3666,13 +4294,204 @@ function runActorWorkflowTests(driverTestConfig) {
     });
     _vitest.test.call(void 0, "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();
       _vitest.expect.call(void 0, next.ticks).toBeGreaterThan(initial.ticks);
     });
+    _vitest.test.call(void 0, "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();
+      }
+      _vitest.expect.call(void 0, state.attempts).toBe(2);
+      _vitest.expect.call(void 0, state.events).toHaveLength(1);
+      _vitest.expect.call(void 0, state.events[0]).toEqual(
+        _vitest.expect.objectContaining({
+          step: _vitest.expect.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: _vitest.expect.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
+    _vitest.test.call(void 0, "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();
+      }
+      _vitest.expect.call(void 0, state.attempts).toBe(2);
+      _vitest.expect.call(void 0, state.errorCount).toBe(1);
+      _vitest.expect.call(void 0, state.lastError).toEqual(
+        _vitest.expect.objectContaining({
+          step: _vitest.expect.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: _vitest.expect.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
+    _vitest.test.call(void 0, "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;
+        _vitest.expect.call(void 0, event).toEqual(
+          _vitest.expect.objectContaining({
+            step: _vitest.expect.objectContaining({
+              stepName: "flaky",
+              attempt: 1,
+              willRetry: true,
+              retryDelay: 1,
+              error: _vitest.expect.objectContaining({
+                name: "Error",
+                message: "workflow hook failed"
+              })
+            })
+          })
+        );
+      } finally {
+        await actor.dispose();
+      }
+    });
+    _vitest.test.call(void 0, "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();
+      _vitest.expect.call(void 0, queuedError).toEqual(
+        _vitest.expect.objectContaining({
+          step: _vitest.expect.objectContaining({
+            stepName: "flaky",
+            attempt: 1,
+            willRetry: true,
+            retryDelay: 1,
+            error: _vitest.expect.objectContaining({
+              name: "Error",
+              message: "workflow hook failed"
+            })
+          })
+        })
+      );
+    });
     _vitest.test.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();
+        }
+        _vitest.expect.call(void 0, state.runCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state.sleepCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state.startCount).toBeGreaterThan(1);
+      }
+    );
+    _vitest.test.call(void 0, "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 _vitest.vi.waitFor(async () => {
+        const wasDestroyed = await observer.wasDestroyed(actorKey);
+        _vitest.expect.call(void 0, wasDestroyed, "actor onDestroy not called").toBeTruthy();
+      });
+      await _vitest.vi.waitFor(async () => {
+        let actorRunning = false;
+        try {
+          await client.workflowDestroyActor.getForId(actorId).resolve();
+          actorRunning = true;
+        } catch (err) {
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
+        }
+        _vitest.expect.call(void 0, actorRunning, "actor still running").toBeFalsy();
+      });
+    });
+    _vitest.test.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();
+        }
+        _vitest.expect.call(void 0, state.runCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state.sleepCount).toBeGreaterThan(0);
+        _vitest.expect.call(void 0, state.startCount).toBeGreaterThan(1);
+      }
+    );
+    _vitest.test.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();
+        }
+        _vitest.expect.call(void 0, state.attempts).toBe(2);
+        _vitest.expect.call(void 0, state.events).toHaveLength(1);
+        _vitest.expect.call(void 0, 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();
+        }
+        _vitest.expect.call(void 0, resumedState.sleepCount).toBeGreaterThanOrEqual(1);
+        _vitest.expect.call(void 0, resumedState.wakeCount).toBeGreaterThanOrEqual(2);
+        _vitest.expect.call(void 0, resumedState.attempts).toBe(2);
+        _vitest.expect.call(void 0, resumedState.events).toHaveLength(1);
+      }
+    );
+    _vitest.test.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);
@@ -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) => {
@@ -4899,6 +5722,225 @@ function runRawWebSocketTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-db-kv-stats.ts
+
+function runActorDbKvStatsTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Database KV Stats Tests", () => {
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, stats.putBatchCalls).toBe(1);
+        _vitest.expect.call(void 0, stats.getBatchCalls).toBe(0);
+        const allKeys = log.flatMap((e) => e.keys);
+        const journalKeys = allKeys.filter((k) => k.includes("journal"));
+        _vitest.expect.call(void 0, journalKeys.length).toBe(0);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, stats.getBatchCalls).toBe(0);
+        _vitest.expect.call(void 0, stats.putBatchCalls).toBe(0);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, combinedStats.putBatchCalls).toBe(updateStats.putBatchCalls);
+        _vitest.expect.call(void 0, combinedStats.getBatchCalls).toBe(updateStats.getBatchCalls);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, stats.putBatchCalls).toBeGreaterThanOrEqual(1);
+        _vitest.expect.call(void 0, 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[")
+        );
+        _vitest.expect.call(void 0, mainChunkKeys.length).toBeGreaterThanOrEqual(1);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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["));
+        _vitest.expect.call(void 0, mainChunkKeys.length).toBe(0);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, stats.putBatchCalls).toBeGreaterThanOrEqual(1);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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")
+        );
+        _vitest.expect.call(void 0, walOrShmKeys.length).toBe(0);
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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) {
+          _vitest.expect.call(void 0, 
+            entry.keys.length
+          ).toBeLessThanOrEqual(128);
+        }
+      },
+      3e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, stats.putBatchCalls).toBeGreaterThan(1);
+        const allKeys = log.flatMap((e) => e.keys);
+        const journalKeys = allKeys.filter(
+          (k) => k.includes("journal")
+        );
+        _vitest.expect.call(void 0, journalKeys.length).toBeGreaterThan(0);
+        const putBatchOps = log.filter(
+          (e) => e.op === "putBatch"
+        );
+        for (const entry of putBatchOps) {
+          _vitest.expect.call(void 0, 
+            entry.keys.length
+          ).toBeLessThanOrEqual(128);
+        }
+      },
+      6e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, count).toBe(200);
+        const integrity = await actor.runIntegrityCheck();
+        _vitest.expect.call(void 0, integrity).toBe("ok");
+      },
+      6e4
+    );
+    _vitest.test.call(void 0, 
+      "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();
+        _vitest.expect.call(void 0, countBefore).toBe(200);
+        await actor.triggerSleep();
+        await waitFor(driverTestConfig, 250);
+        const countAfter = await actor.getRowCount();
+        _vitest.expect.call(void 0, countAfter).toBe(200);
+        const integrity = await actor.runIntegrityCheck();
+        _vitest.expect.call(void 0, integrity).toBe("ok");
+      },
+      6e4
+    );
+  });
+}
+
 // src/driver-test-suite/tests/request-access.ts
 
 function runRequestAccessTests(driverTestConfig) {
@@ -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);
           });
         }
       });
@@ -5061,7 +6105,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     const parsedConfig = registry.parseConfig();
     const managerDriver = (_a = driver.manager) == null ? void 0 : _a.call(driver, parsedConfig);
     _invariant2.default.call(void 0, managerDriver, "missing manager driver");
-    const { router } = _chunk3B6PCYJBcjs.buildManagerRouter.call(void 0, 
+    const { router } = _chunkCGGGBIDPcjs.buildManagerRouter.call(void 0, 
       parsedConfig,
       managerDriver,
       () => upgradeWebSocket
@@ -5085,10 +6129,13 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     nodeWebSocket.injectWebSocket(server);
     const address = server.address();
-    _invariant2.default.call(void 0, address && typeof address !== "string", "missing server address");
+    _invariant2.default.call(void 0, 
+      address && typeof address !== "string",
+      "missing server address"
+    );
     const port = address.port;
     const serverEndpoint = `http://127.0.0.1:${port}`;
-    _chunkH5TSEPN4cjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
+    _chunkCMQPDBBRcjs.logger.call(void 0, ).info({ msg: "test serer listening", port });
     const cleanup = async () => {
       await new Promise(
         (resolve) => server.close(() => resolve(void 0))