rivetkit 2.0.23 → 2.0.24

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

@@ -1,30 +1,30 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunkHNYF4T36cjs = require('../chunk-HNYF4T36.cjs');
+var _chunkCHLZBSI2cjs = require('../chunk-CHLZBSI2.cjs');
 
 
 
-var _chunkXYK5PY3Bcjs = require('../chunk-XYK5PY3B.cjs');
+var _chunkFVAKREFBcjs = require('../chunk-FVAKREFB.cjs');
 
 
 
 
-var _chunkXSDSNHSEcjs = require('../chunk-XSDSNHSE.cjs');
+var _chunkYC5DUHPMcjs = require('../chunk-YC5DUHPM.cjs');
 
 
-var _chunk54DVMQPTcjs = require('../chunk-54DVMQPT.cjs');
+var _chunkESMTDP7Gcjs = require('../chunk-ESMTDP7G.cjs');
 
 
 
-var _chunkD6PCH7FRcjs = require('../chunk-D6PCH7FR.cjs');
-require('../chunk-SN4KWTRA.cjs');
+var _chunk4SHILYS5cjs = require('../chunk-4SHILYS5.cjs');
+require('../chunk-J3HZJF2P.cjs');
 
 
-var _chunkNCUALX2Qcjs = require('../chunk-NCUALX2Q.cjs');
+var _chunk5BZO5XPScjs = require('../chunk-5BZO5XPS.cjs');
 
 
 
-var _chunkJMLTKMJ7cjs = require('../chunk-JMLTKMJ7.cjs');
+var _chunkD3SLADUDcjs = require('../chunk-D3SLADUD.cjs');
 
 
 
@@ -35,26 +35,25 @@ var _chunkJMLTKMJ7cjs = require('../chunk-JMLTKMJ7.cjs');
 
 
 
-var _chunk3JYSUFETcjs = require('../chunk-3JYSUFET.cjs');
+var _chunk3543NCSNcjs = require('../chunk-3543NCSN.cjs');
 
 
 
-var _chunkC56XVVV4cjs = require('../chunk-C56XVVV4.cjs');
+var _chunkDLK5YCTNcjs = require('../chunk-DLK5YCTN.cjs');
 
 
 
-var _chunkKSRXX3Z4cjs = require('../chunk-KSRXX3Z4.cjs');
+var _chunkD6762AOAcjs = require('../chunk-D6762AOA.cjs');
 
 // src/driver-test-suite/mod.ts
 var _nodeserver = require('@hono/node-server');
 var _nodews = require('@hono/node-ws');
-var _bundlerequire = require('bundle-require');
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
 var _vitest = require('vitest');
 
 // src/driver-test-suite/log.ts
 function logger() {
-  return _chunkC56XVVV4cjs.getLogger.call(void 0, "test-suite");
+  return _chunkDLK5YCTNcjs.getLogger.call(void 0, "test-suite");
 }
 
 // src/driver-test-suite/tests/action-features.ts
@@ -65,43 +64,26 @@ function logger() {
 
 // src/driver-test-suite/test-inline-client-driver.ts
 var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
-function createTestInlineClientDriver(endpoint, encoding, transport) {
+function createTestInlineClientDriver(endpoint, encoding) {
   return {
     getForId(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getForId",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getForId", [input]);
     },
     getWithKey(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getWithKey",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getWithKey", [input]);
     },
     getOrCreateWithKey(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "getOrCreateWithKey",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "getOrCreateWithKey", [
+        input
+      ]);
     },
     createActor(input) {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "createActor",
-        [input]
-      );
+      return makeInlineRequest(endpoint, encoding, "createActor", [
+        input
+      ]);
+    },
+    listActors(input) {
+      return makeInlineRequest(endpoint, encoding, "listActors", [input]);
     },
     async sendRequest(actorId, actorRequest) {
       var _a;
@@ -121,7 +103,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
         to: url
       });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunk3JYSUFETcjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunk3543NCSNcjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
@@ -137,7 +119,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkD6PCH7FRcjs.ActorError)(
+              throw new (0, _chunk4SHILYS5cjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -145,7 +127,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkD6PCH7FRcjs.ActorError)) {
+          if (!(e instanceof _chunk4SHILYS5cjs.ActorError)) {
             return response;
           }
           throw e;
@@ -153,8 +135,8 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       }
       return response;
     },
-    async openWebSocket(path, actorId, encoding2, params, connId, connToken) {
-      const WebSocket2 = await _chunkNCUALX2Qcjs.importWebSocket.call(void 0, );
+    async openWebSocket(path, actorId, encoding2, params) {
+      const WebSocket2 = await _chunk5BZO5XPScjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
@@ -165,20 +147,24 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       });
       const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
       const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
-      logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
       const protocols = [];
-      protocols.push(`${_chunk3JYSUFETcjs.WS_PROTOCOL_TARGET}actor`);
-      protocols.push(`${_chunk3JYSUFETcjs.WS_PROTOCOL_ACTOR}${actorId}`);
-      protocols.push(`${_chunk3JYSUFETcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
-      protocols.push(`${_chunk3JYSUFETcjs.WS_PROTOCOL_TRANSPORT}${transport}`);
+      protocols.push(_chunk3543NCSNcjs.WS_PROTOCOL_STANDARD);
+      protocols.push(`${_chunk3543NCSNcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(`${_chunk3543NCSNcjs.WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
+      protocols.push(`${_chunk3543NCSNcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
       protocols.push(
-        `${_chunk3JYSUFETcjs.WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+        `${_chunk3543NCSNcjs.WS_TEST_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
       );
       if (params !== void 0) {
         protocols.push(
-          `${_chunk3JYSUFETcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+          `${_chunk3543NCSNcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
         );
       }
+      logger().debug({
+        msg: "connecting to websocket",
+        url: finalWsUrl,
+        protocols
+      });
       const ws = new WebSocket2(finalWsUrl, protocols);
       return ws;
     },
@@ -204,7 +190,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 	return makeInlineRequest<Response>(
     // 		endpoint,
     // 		encoding,
-    // 		transport,
     // 		"action",
     // 		[undefined, actorQuery, encoding, params, name, args],
     // 	);
@@ -219,7 +204,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 	return makeInlineRequest<string>(
     // 		endpoint,
     // 		encodingKind,
-    // 		transport,
     // 		"resolveActorId",
     // 		[undefined, actorQuery, encodingKind, params],
     // 	);
@@ -341,7 +325,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 		actorId,
     // 		encoding,
     // 		connectionId,
-    // 		transport,
     // 	});
     //
     // 	const result = await fetch(
@@ -353,7 +336,6 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 			},
     // 			body: JSON.stringify({
     // 				encoding,
-    // 				transport,
     // 				method: "sendHttpMessage",
     // 				args: [
     // 					undefined,
@@ -424,7 +406,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 			if (errorData.error) {
     // 				// Handle both error formats:
     // 				// 1. { error: { code, message, metadata } } - structured format
-    // 				// 2. { error: "message" } - simple string format (from custom onFetch handlers)
+    // 				// 2. { error: "message" } - simple string format (from custom onRequest handlers)
     // 				if (typeof errorData.error === "object") {
     // 					throw new ClientActorError(
     // 						errorData.error.code,
@@ -433,7 +415,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // 					);
     // 				}
     // 				// For simple string errors, just return the response as-is
-    // 				// This allows custom onFetch handlers to return their own error formats
+    // 				// This allows custom onRequest handlers to return their own error formats
     // 			}
     // 		} catch (e) {
     // 			// If it's not our error format, just return the response as-is
@@ -510,11 +492,10 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
     // },
   };
 }
-async function makeInlineRequest(endpoint, encoding, transport, method, args) {
+async function makeInlineRequest(endpoint, encoding, method, args) {
   logger().debug({
     msg: "sending inline request",
     encoding,
-    transport,
     method,
     args
   });
@@ -525,7 +506,6 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
     },
     body: cbor.encode({
       encoding,
-      transport,
       method,
       args
     }),
@@ -543,14 +523,14 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkD6PCH7FRcjs.ActorError)(
+    throw new (0, _chunk4SHILYS5cjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunk3JYSUFETcjs.assertUnreachable.call(void 0, callResponse);
+    _chunk3543NCSNcjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -562,31 +542,27 @@ async function setupDriverTest(c, driverTestConfig) {
     _vitest.vi.setSystemTime(FAKE_TIME);
   }
   const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
-  c.onTestFinished(cleanup);
+  c.onTestFinished(() => {
+    logger().info("cleaning up test");
+    cleanup();
+  });
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunk54DVMQPTcjs.createClient.call(void 0, {
+    client = _chunkESMTDP7Gcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
-      transport: driverTestConfig.transport,
       encoding: driverTestConfig.encoding
     });
   } else if (driverTestConfig.clientType === "inline") {
-    const transport = _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"));
     const encoding = _nullishCoalesce(driverTestConfig.encoding, () => ( "bare"));
-    const managerDriver = createTestInlineClientDriver(
-      endpoint,
-      encoding,
-      transport
-    );
-    const runConfig = _chunkJMLTKMJ7cjs.RunnerConfigSchema.parse({
-      transport,
+    const managerDriver = createTestInlineClientDriver(endpoint, encoding);
+    const runConfig = _chunkD3SLADUDcjs.RunnerConfigSchema.parse({
       encoding
     });
-    client = _chunkD6PCH7FRcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
+    client = _chunk4SHILYS5cjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunk3JYSUFETcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunk3543NCSNcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -838,9 +814,7 @@ function runActorConnTests(driverTestConfig) {
       });
     });
     _vitest.describe.call(void 0, "Lifecycle Hooks", () => {
-      _vitest.test.skipIf(
-        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
-      )("should trigger lifecycle hooks", async (c) => {
+      _vitest.test.call(void 0, "should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -851,7 +825,7 @@ function runActorConnTests(driverTestConfig) {
         const connection = connHandle.connect();
         const events = await connection.getEvents();
         _vitest.expect.call(void 0, events).toEqual([
-          "onStart",
+          "onWake",
           "onBeforeConnect",
           "onConnect"
         ]);
@@ -865,18 +839,18 @@ function runActorConnTests(driverTestConfig) {
             _vitest.expect.call(void 0, finalEvents).toBeOneOf([
               // Still active
               [
-                "onStart",
+                "onWake",
                 "onBeforeConnect",
                 "onConnect",
                 "onDisconnect"
               ],
               // Went to sleep and woke back up
               [
-                "onStart",
+                "onWake",
                 "onBeforeConnect",
                 "onConnect",
                 "onDisconnect",
-                "onStart"
+                "onWake"
               ]
             ]);
           },
@@ -972,9 +946,7 @@ function runActorConnStateTests(driverTestConfig) {
       });
     });
     _vitest.describe.call(void 0, "Connection Lifecycle", () => {
-      _vitest.test.skipIf(
-        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
-      )("should track connection and disconnection events", async (c) => {
+      _vitest.test.call(void 0, "should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const debugHandle = client.connStateActor.getOrCreate(
           void 0,
@@ -1075,6 +1047,191 @@ function runActorConnStateTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-destroy.ts
+
+function runActorDestroyTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Destroy Tests", () => {
+    _vitest.test.call(void 0, "actor destroy clears state (without connect)", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = "test-destroy-without-connect";
+      const observer = client.destroyObserver.getOrCreate(["observer"]);
+      await observer.reset();
+      const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+      await destroyActor.setValue(42);
+      const value = await destroyActor.getValue();
+      _vitest.expect.call(void 0, value).toBe(42);
+      const actorId = await destroyActor.resolve();
+      await destroyActor.destroy();
+      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.destroyActor.getForId(actorId).getValue();
+          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();
+      });
+      let existsById = false;
+      try {
+        await client.destroyActor.getForId(actorId).getValue();
+        existsById = 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, 
+        existsById,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      let existsByKey = false;
+      try {
+        await client.destroyActor.get(["test-destroy-without-connect"]).resolve();
+        existsByKey = 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, 
+        existsByKey,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      const newActor = client.destroyActor.getOrCreate([
+        "test-destroy-without-connect"
+      ]);
+      const newValue = await newActor.getValue();
+      _vitest.expect.call(void 0, newValue).toBe(0);
+    });
+    _vitest.test.call(void 0, "actor destroy clears state (with connect)", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = "test-destroy-with-connect";
+      const observer = client.destroyObserver.getOrCreate(["observer"]);
+      await observer.reset();
+      const destroyActorHandle = client.destroyActor.getOrCreate([
+        actorKey
+      ]);
+      const actorId = await destroyActorHandle.resolve();
+      const destroyActor = destroyActorHandle.connect();
+      await destroyActor.setValue(99);
+      const value = await destroyActor.getValue();
+      _vitest.expect.call(void 0, value).toBe(99);
+      await destroyActor.destroy();
+      await destroyActor.dispose();
+      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.destroyActor.getForId(actorId).getValue();
+          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();
+      });
+      let existsById = false;
+      try {
+        await client.destroyActor.getForId(actorId).getValue();
+        existsById = 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, 
+        existsById,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      let existsByKey = false;
+      try {
+        await client.destroyActor.get(["test-destroy-with-connect"]).resolve();
+        existsByKey = 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, 
+        existsByKey,
+        "actor should not exist after destroy"
+      ).toBeFalsy();
+      const newActor = client.destroyActor.getOrCreate([
+        "test-destroy-with-connect"
+      ]);
+      const newValue = await newActor.getValue();
+      _vitest.expect.call(void 0, newValue).toBe(0);
+    });
+    _vitest.test.call(void 0, "actor destroy allows recreation via getOrCreate with resolve", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = "test-destroy-getorcreate-resolve";
+      const observer = client.destroyObserver.getOrCreate(["observer"]);
+      await observer.reset();
+      const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+      await destroyActor.setValue(123);
+      const value = await destroyActor.getValue();
+      _vitest.expect.call(void 0, value).toBe(123);
+      const actorId = await destroyActor.resolve();
+      await destroyActor.destroy();
+      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.destroyActor.getForId(actorId).getValue();
+          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();
+      });
+      const newHandle = client.destroyActor.getOrCreate([actorKey]);
+      const newActorId = await newHandle.resolve();
+      const newValue = await newHandle.getValue();
+      _vitest.expect.call(void 0, newValue).toBe(0);
+    });
+    _vitest.test.call(void 0, "actor destroy allows recreation via create", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actorKey = "test-destroy-create";
+      const observer = client.destroyObserver.getOrCreate(["observer"]);
+      await observer.reset();
+      const initialHandle = await client.destroyActor.create([actorKey]);
+      await initialHandle.setValue(456);
+      const value = await initialHandle.getValue();
+      _vitest.expect.call(void 0, value).toBe(456);
+      const actorId = await initialHandle.resolve();
+      await initialHandle.destroy();
+      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.destroyActor.getForId(actorId).getValue();
+          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();
+      });
+      const newHandle = await client.destroyActor.create([actorKey]);
+      const newActorId = await newHandle.resolve();
+      const newValue = await newHandle.getValue();
+      _vitest.expect.call(void 0, newValue).toBe(0);
+    });
+  });
+}
+
 // src/driver-test-suite/tests/actor-driver.ts
 
 
@@ -1143,12 +1300,12 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 1e3;
-var sleep = _chunkXYK5PY3Bcjs.actor.call(void 0, {
+var sleep = _chunkFVAKREFBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1172,13 +1329,13 @@ var sleep = _chunkXYK5PY3Bcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunkXYK5PY3Bcjs.actor.call(void 0, {
+var sleepWithLongRpc = _chunkFVAKREFBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1190,7 +1347,7 @@ var sleepWithLongRpc = _chunkXYK5PY3Bcjs.actor.call(void 0, {
     },
     longRunningRpc: async (c) => {
       c.log.info("starting long running rpc");
-      c.vars.longRunningResolve = _chunkC56XVVV4cjs.promiseWithResolvers.call(void 0, );
+      c.vars.longRunningResolve = _chunkDLK5YCTNcjs.promiseWithResolvers.call(void 0, );
       c.broadcast("waiting");
       await c.vars.longRunningResolve.promise;
       c.log.info("finished long running rpc");
@@ -1204,15 +1361,15 @@ var sleepWithLongRpc = _chunkXYK5PY3Bcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunkXYK5PY3Bcjs.actor.call(void 0, {
+var sleepWithRawHttp = _chunkFVAKREFBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
-  onFetch: async (c, request) => {
+  onRequest: async (c, request) => {
     c.state.requestCount += 1;
     const url = new URL(request.url);
     if (url.pathname === "/long-request") {
@@ -1241,15 +1398,15 @@ var sleepWithRawHttp = _chunkXYK5PY3Bcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunkXYK5PY3Bcjs.actor.call(void 0, {
+var sleepWithRawWebSocket = _chunkFVAKREFBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
-  onWebSocket: (c, websocket, opts) => {
+  onWebSocket: (c, websocket) => {
     c.state.connectionCount += 1;
     c.log.info({
       msg: "websocket connected",
@@ -1304,12 +1461,12 @@ var sleepWithRawWebSocket = _chunkXYK5PY3Bcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunkXYK5PY3Bcjs.actor.call(void 0, {
+var sleepWithNoSleepOption = _chunkFVAKREFBcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
-  onStart: (c) => {
+  onWake: (c) => {
     c.state.startCount += 1;
   },
-  onStop: (c) => {
+  onSleep: (c) => {
     c.state.sleepCount += 1;
   },
   actions: {
@@ -1626,10 +1783,6 @@ function runActorDriverTests(driverTestConfig) {
   _vitest.describe.call(void 0, "Actor Driver Tests", () => {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
-  });
-}
-function runActorDriverTestsWithTransport(driverTestConfig) {
-  _vitest.describe.call(void 0, "Actor Driver Tests", () => {
     runActorSleepTests(driverTestConfig);
   });
 }
@@ -1674,8 +1827,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(_chunkKSRXX3Z4cjs.INTERNAL_ERROR_CODE);
-          _vitest.expect.call(void 0, error.message).toBe(_chunkKSRXX3Z4cjs.INTERNAL_ERROR_DESCRIPTION);
+          _vitest.expect.call(void 0, error.code).toBe(_chunkD6762AOAcjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunkD6762AOAcjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -1783,7 +1936,7 @@ function runActorHandleTests(driverTestConfig) {
           _vitest.expect.fail("did not error on duplicate create");
         } catch (err) {
           _vitest.expect.call(void 0, err.group).toBe("actor");
-          _vitest.expect.call(void 0, err.code).toBe("already_exists");
+          _vitest.expect.call(void 0, err.code).toBe("duplicate_key");
         }
       });
       _vitest.test.call(void 0, ".get().resolve() errors for non-existent actor", async (c) => {
@@ -1846,13 +1999,13 @@ function runActorHandleTests(driverTestConfig) {
           "test-lifecycle-handle"
         ]);
         const initialEvents = await handle.getEvents();
-        _vitest.expect.call(void 0, initialEvents).toContain("onStart");
+        _vitest.expect.call(void 0, initialEvents).toContain("onWake");
         const sameHandle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle-handle"
         ]);
         const events = await sameHandle.getEvents();
-        _vitest.expect.call(void 0, events).toContain("onStart");
-        _vitest.expect.call(void 0, events.filter((e) => e === "onStart").length).toBe(1);
+        _vitest.expect.call(void 0, events).toContain("onWake");
+        _vitest.expect.call(void 0, events.filter((e) => e === "onWake").length).toBe(1);
       });
       _vitest.test.call(void 0, "should trigger lifecycle hooks for each Action call", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -1860,7 +2013,7 @@ function runActorHandleTests(driverTestConfig) {
           "test-lifecycle-action"
         ]);
         const initialEvents = await viewHandle.getEvents();
-        _vitest.expect.call(void 0, initialEvents).toContain("onStart");
+        _vitest.expect.call(void 0, initialEvents).toContain("onWake");
         _vitest.expect.call(void 0, initialEvents).not.toContain("onBeforeConnect");
         _vitest.expect.call(void 0, initialEvents).not.toContain("onConnect");
         _vitest.expect.call(void 0, initialEvents).not.toContain("onDisconnect");
@@ -1912,7 +2065,7 @@ function runActorHandleTests(driverTestConfig) {
         await trackingHandle1.increment(5);
         await trackingHandle2.increment(10);
         const events = await viewHandle.getEvents();
-        _vitest.expect.call(void 0, events.filter((e) => e === "onStart").length).toBe(1);
+        _vitest.expect.call(void 0, events.filter((e) => e === "onWake").length).toBe(1);
         _vitest.expect.call(void 0, 
           events.filter((e) => e === "onBeforeConnect").length
         ).toBe(2);
@@ -1925,6 +2078,159 @@ function runActorHandleTests(driverTestConfig) {
   });
 }
 
+// src/driver-test-suite/tests/actor-conn-hibernation.ts
+
+
+// fixtures/driver-test-suite/hibernation.ts
+var HIBERNATION_SLEEP_TIMEOUT = 500;
+var hibernationActor = _chunkFVAKREFBcjs.actor.call(void 0, {
+  state: {
+    sleepCount: 0,
+    wakeCount: 0
+  },
+  createConnState: (c) => {
+    return {
+      count: 0,
+      connectCount: 0,
+      disconnectCount: 0
+    };
+  },
+  onWake: (c) => {
+    c.state.wakeCount += 1;
+  },
+  onSleep: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onConnect: (c, conn) => {
+    conn.state.connectCount += 1;
+  },
+  onDisconnect: (c, conn) => {
+    conn.state.disconnectCount += 1;
+  },
+  actions: {
+    // Basic RPC that returns a simple value
+    ping: (c) => {
+      return "pong";
+    },
+    // Increment the connection's count
+    connIncrement: (c) => {
+      c.conn.state.count += 1;
+      return c.conn.state.count;
+    },
+    // Get the connection's count
+    getConnCount: (c) => {
+      return c.conn.state.count;
+    },
+    // Get the connection's lifecycle counts
+    getConnLifecycleCounts: (c) => {
+      return {
+        connectCount: c.conn.state.connectCount,
+        disconnectCount: c.conn.state.disconnectCount
+      };
+    },
+    // Get all connection IDs
+    getConnectionIds: (c) => {
+      return c.conns.entries().map((x) => x[0]).toArray();
+    },
+    // Get actor sleep/wake counts
+    getActorCounts: (c) => {
+      return {
+        sleepCount: c.state.sleepCount,
+        wakeCount: c.state.wakeCount
+      };
+    },
+    // Trigger sleep
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: HIBERNATION_SLEEP_TIMEOUT
+  }
+});
+
+// src/driver-test-suite/tests/actor-conn-hibernation.ts
+function runActorConnHibernationTests(driverTestConfig) {
+  var _a;
+  _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.hibernation)(
+    "Connection Hibernation",
+    () => {
+      _vitest.test.call(void 0, "basic conn hibernation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const hibernatingActor = client.hibernationActor.getOrCreate().connect();
+        const ping1 = await hibernatingActor.ping();
+        _vitest.expect.call(void 0, ping1).toBe("pong");
+        await hibernatingActor.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        const ping2 = await hibernatingActor.ping();
+        _vitest.expect.call(void 0, ping2).toBe("pong");
+        await hibernatingActor.dispose();
+      });
+      _vitest.test.call(void 0, "conn state persists through hibernation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const hibernatingActor = client.hibernationActor.getOrCreate().connect();
+        const count1 = await hibernatingActor.connIncrement();
+        _vitest.expect.call(void 0, count1).toBe(1);
+        const count2 = await hibernatingActor.connIncrement();
+        _vitest.expect.call(void 0, count2).toBe(2);
+        const initialLifecycle = await hibernatingActor.getConnLifecycleCounts();
+        _vitest.expect.call(void 0, initialLifecycle.connectCount).toBe(1);
+        _vitest.expect.call(void 0, initialLifecycle.disconnectCount).toBe(0);
+        const initialActorCounts = await hibernatingActor.getActorCounts();
+        _vitest.expect.call(void 0, initialActorCounts.wakeCount).toBe(1);
+        _vitest.expect.call(void 0, initialActorCounts.sleepCount).toBe(0);
+        await hibernatingActor.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        const count3 = await hibernatingActor.getConnCount();
+        _vitest.expect.call(void 0, count3).toBe(2);
+        const finalLifecycle = await hibernatingActor.getConnLifecycleCounts();
+        _vitest.expect.call(void 0, finalLifecycle.connectCount).toBe(1);
+        _vitest.expect.call(void 0, finalLifecycle.disconnectCount).toBe(0);
+        const finalActorCounts = await hibernatingActor.getActorCounts();
+        _vitest.expect.call(void 0, finalActorCounts.wakeCount).toBe(2);
+        _vitest.expect.call(void 0, finalActorCounts.sleepCount).toBe(1);
+        await hibernatingActor.dispose();
+      });
+      _vitest.test.call(void 0, "closing connection during hibernation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const conn1 = client.hibernationActor.getOrCreate().connect();
+        await conn1.ping();
+        const connectionIds = await conn1.getConnectionIds();
+        _vitest.expect.call(void 0, connectionIds.length).toBe(1);
+        const conn1Id = connectionIds[0];
+        await conn1.triggerSleep();
+        await waitFor(
+          driverTestConfig,
+          HIBERNATION_SLEEP_TIMEOUT + 100
+        );
+        await conn1.dispose();
+        await waitFor(driverTestConfig, 250);
+        const conn2 = client.hibernationActor.getOrCreate().connect();
+        await _vitest.vi.waitFor(
+          async () => {
+            const newConnectionIds = await conn2.getConnectionIds();
+            _vitest.expect.call(void 0, newConnectionIds.length).toBe(1);
+            _vitest.expect.call(void 0, newConnectionIds[0]).not.toBe(conn1Id);
+          },
+          {
+            timeout: 5e3,
+            interval: 100
+          }
+        );
+        const lifecycle = await conn2.getConnLifecycleCounts();
+        _vitest.expect.call(void 0, lifecycle.disconnectCount).toBe(0);
+        await conn2.dispose();
+      });
+    }
+  );
+}
+
 // src/driver-test-suite/tests/actor-inline-client.ts
 
 function runActorInlineClientTests(driverTestConfig) {
@@ -2039,7 +2345,7 @@ function runActorInspectorTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Manager Inspector", () => {
       _vitest.test.call(void 0, "should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2059,7 +2365,7 @@ function runActorInspectorTests(driverTestConfig) {
         );
         await client.counter.create(["test-actor-1"]);
         await client.counter.create(["test-actor-2"]);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2088,7 +2394,7 @@ function runActorInspectorTests(driverTestConfig) {
         const actorKey2 = ["test-cursor-2"];
         await client.counter.create(actorKey1);
         await client.counter.create(actorKey2);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2116,7 +2422,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2131,7 +2437,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2158,7 +2464,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2182,7 +2488,7 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-get-by-id"]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2199,7 +2505,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2221,7 +2527,7 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createManagerInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createManagerInspectorClient.call(void 0, 
           `${endpoint}/inspect`,
           {
             headers: {
@@ -2246,12 +2552,12 @@ function runActorInspectorTests(driverTestConfig) {
       _vitest.test.call(void 0, "should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2267,12 +2573,12 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-ping"]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2291,12 +2597,12 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state"]);
         const actorId = await handle.resolve();
         await handle.increment(5);
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2321,12 +2627,12 @@ function runActorInspectorTests(driverTestConfig) {
           "test-state-replace"
         ]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2354,12 +2660,12 @@ function runActorInspectorTests(driverTestConfig) {
         ]);
         const actorId = await handle.resolve();
         await handle.increment(3);
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2396,12 +2702,12 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2427,12 +2733,12 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2461,12 +2767,12 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2495,12 +2801,12 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-rpcs"]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2522,12 +2828,12 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-db"]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2552,12 +2858,12 @@ function runActorInspectorTests(driverTestConfig) {
         );
         const handle = await client.counter.create(["test-db-query"]);
         const actorId = await handle.resolve();
-        const http = _chunkXSDSNHSEcjs.createActorInspectorClient.call(void 0, 
+        const http = _chunkYC5DUHPMcjs.createActorInspectorClient.call(void 0, 
           `${endpoint}/actors/inspect`,
           {
             headers: {
               Authorization: `Bearer token`,
-              [_chunk3JYSUFETcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              [_chunk3543NCSNcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
                 getForId: { name: "counter", actorId }
               })
             }
@@ -2602,7 +2908,7 @@ function runActorMetadataTests(driverTestConfig) {
         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 onStart", async (c) => {
+      _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();
@@ -2721,113 +3027,6 @@ function runActorOnStateChangeTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/actor-reconnect.ts
-
-function runActorReconnectTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "Actor Reconnection Tests", () => {
-    _vitest.test.call(void 0, "should reconnect and preserve connection state after non-clean disconnect", async (c) => {
-      const { client, endpoint } = await setupDriverTest(
-        c,
-        driverTestConfig
-      );
-      const handle = client.counterConn.getOrCreate(["test-reconnect"]);
-      const connection = handle.connect();
-      await connection.increment(5);
-      const connCount1 = await connection.getConnectionCount();
-      _vitest.expect.call(void 0, connCount1).toBe(1);
-      const connRaw = connection;
-      await forceUncleanDisconnect(
-        endpoint,
-        connRaw.actorId,
-        connRaw.connectionId
-      );
-      await _vitest.vi.waitFor(
-        async () => {
-          const countAfterReconnect = await connection.getCount();
-          _vitest.expect.call(void 0, countAfterReconnect).toBe(5);
-        },
-        { timeout: 5e3, interval: 100 }
-      );
-      const connCount2 = await connection.getConnectionCount();
-      _vitest.expect.call(void 0, connCount2).toBe(1);
-      const newCount = await connection.getCount();
-      _vitest.expect.call(void 0, newCount).toBe(5);
-      await connection.dispose();
-    });
-    _vitest.test.call(void 0, "should not preserve connection state after clean disconnect", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const handle = client.counterConn.getOrCreate([
-        "test-clean-disconnect"
-      ]);
-      const connection = handle.connect();
-      await connection.increment(10);
-      const connCount1 = await connection.getConnectionCount();
-      _vitest.expect.call(void 0, connCount1).toBe(1);
-      await connection.dispose();
-      await _vitest.vi.waitFor(
-        async () => {
-          const handle2 = client.counterConn.get([
-            "test-clean-disconnect"
-          ]);
-          const connCount = await handle2.getConnectionCount();
-          _vitest.expect.call(void 0, connCount).toBe(1);
-        },
-        { timeout: 5e3 }
-      );
-      const connection2 = handle.connect();
-      const countNewConnection = await connection2.getCount();
-      _vitest.expect.call(void 0, countNewConnection).toBe(0);
-      const connCount3 = await connection2.getConnectionCount();
-      _vitest.expect.call(void 0, connCount3).toBe(1);
-      await connection2.dispose();
-    });
-    _vitest.test.call(void 0, "should handle multiple non-clean disconnects and reconnects", async (c) => {
-      const { client, endpoint } = await setupDriverTest(
-        c,
-        driverTestConfig
-      );
-      const handle = client.counterConn.getOrCreate([
-        "test-multiple-reconnect"
-      ]);
-      const connection = handle.connect();
-      await connection.setCount(100);
-      for (let i = 0; i < 3; i++) {
-        await connection.increment(1);
-        const connRaw = connection;
-        await forceUncleanDisconnect(
-          endpoint,
-          connRaw.actorId,
-          connRaw.connectionId
-        );
-        await _vitest.vi.waitFor(
-          async () => {
-            const countAfter = await connection.getCount();
-            _vitest.expect.call(void 0, countAfter).toBe(101 + i);
-          },
-          { timeout: 5e3 }
-        );
-        const connCount = await connection.getConnectionCount();
-        _vitest.expect.call(void 0, connCount).toBe(1);
-      }
-      const finalCount = await connection.getCount();
-      _vitest.expect.call(void 0, finalCount).toBe(103);
-      await connection.dispose();
-    });
-  });
-}
-async function forceUncleanDisconnect(endpoint, actorId, connId) {
-  const response = await fetch(
-    `${endpoint}/.test/force-disconnect?actor=${actorId}&conn=${connId}`,
-    {
-      method: "POST"
-    }
-  );
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Failed to force disconnect: ${text}`);
-  }
-}
-
 // src/driver-test-suite/tests/actor-vars.ts
 
 function runActorVarsTests(driverTestConfig) {
@@ -2922,7 +3121,7 @@ function runManagerDriverTests(driverTestConfig) {
           _vitest.expect.fail("did not error on duplicate create");
         } catch (err) {
           _vitest.expect.call(void 0, err.group).toBe("actor");
-          _vitest.expect.call(void 0, err.code).toBe("already_exists");
+          _vitest.expect.call(void 0, err.code).toBe("duplicate_key");
         }
         const count = await counter.increment(0);
         _vitest.expect.call(void 0, count).toBe(5);
@@ -3170,7 +3369,7 @@ function runRawHttpTests(driverTestConfig) {
       _vitest.expect.call(void 0, response.ok).toBe(false);
       _vitest.expect.call(void 0, response.status).toBe(404);
     });
-    _vitest.test.call(void 0, "should return 404 when no onFetch handler defined", async (c) => {
+    _vitest.test.call(void 0, "should return 404 when no onRequest handler defined", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpNoHandlerActor.getOrCreate([
         "no-handler"
@@ -3179,7 +3378,7 @@ function runRawHttpTests(driverTestConfig) {
       _vitest.expect.call(void 0, response.ok).toBe(false);
       _vitest.expect.call(void 0, response.status).toBe(404);
     });
-    _vitest.test.call(void 0, "should return 500 error when onFetch returns void", async (c) => {
+    _vitest.test.call(void 0, "should return 500 error when onRequest returns void", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpVoidReturnActor.getOrCreate([
         "void-return"
@@ -3190,7 +3389,7 @@ function runRawHttpTests(driverTestConfig) {
       try {
         const errorData = await response.json();
         _vitest.expect.call(void 0, errorData.message).toContain(
-          "onFetch handler must return a Response"
+          "onRequest handler must return a Response"
         );
       } catch (e3) {
       }
@@ -3373,7 +3572,7 @@ function runRawHttpTests(driverTestConfig) {
 
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw http request properties", () => {
-    _vitest.test.call(void 0, "should pass all Request properties correctly to onFetch", async (c) => {
+    _vitest.test.call(void 0, "should pass all Request properties correctly to onRequest", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3589,7 +3788,7 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       _vitest.expect.call(void 0, data.searchParams.param).toBe(longValue);
       _vitest.expect.call(void 0, data.search.length).toBeGreaterThan(1e3);
     });
-    _vitest.test.call(void 0, "should handle large request bodies", async (c) => {
+    _vitest.test.skip("should handle large request bodies", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate([
         "test"
@@ -3636,9 +3835,6 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         body: ""
       });
       _vitest.expect.call(void 0, response.ok).toBe(true);
-      const data = await response.json();
-      _vitest.expect.call(void 0, data.body).toBeNull();
-      _vitest.expect.call(void 0, data.bodyText).toBe("");
     });
     _vitest.test.call(void 0, "should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
@@ -4165,7 +4361,6 @@ function runDriverTests(driverTestConfigPartial) {
       const encodings = ["bare", "cbor", "json"];
       for (const encoding of encodings) {
         _vitest.describe.call(void 0, `encoding (${encoding})`, () => {
-          var _a2;
           const driverTestConfig = {
             ...driverTestConfigPartial,
             clientType,
@@ -4173,31 +4368,11 @@ function runDriverTests(driverTestConfigPartial) {
           };
           runActorDriverTests(driverTestConfig);
           runManagerDriverTests(driverTestConfig);
-          const transports = ((_a2 = driverTestConfig.skip) == null ? void 0 : _a2.sse) ? ["websocket"] : ["websocket", "sse"];
-          for (const transport of transports) {
-            _vitest.describe.call(void 0, `transport (${transport})`, () => {
-              runActorConnTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorConnStateTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorReconnectTests({
-                ...driverTestConfig,
-                transport
-              });
-              runRequestAccessTests({
-                ...driverTestConfig,
-                transport
-              });
-              runActorDriverTestsWithTransport({
-                ...driverTestConfig,
-                transport
-              });
-            });
-          }
+          runActorConnTests(driverTestConfig);
+          runActorConnStateTests(driverTestConfig);
+          runActorConnHibernationTests(driverTestConfig);
+          runActorDestroyTests(driverTestConfig);
+          runRequestAccessTests(driverTestConfig);
           runActorHandleTests(driverTestConfig);
           runActionFeaturesTests(driverTestConfig);
           runActorVarsTests(driverTestConfig);
@@ -4215,11 +4390,7 @@ function runDriverTests(driverTestConfigPartial) {
   }
 }
 async function createTestRuntime(registryPath, driverFactory) {
-  const {
-    mod: { registry }
-  } = await _bundlerequire.bundleRequire.call(void 0, {
-    filepath: registryPath
-  });
+  const { registry } = await Promise.resolve().then(() => _interopRequireWildcard(require(registryPath)));
   registry.config.test.enabled = true;
   const {
     driver,
@@ -4238,7 +4409,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     };
   } else {
     let upgradeWebSocket;
-    const config = _chunkJMLTKMJ7cjs.RunnerConfigSchema.parse({
+    const config = _chunkD3SLADUDcjs.RunnerConfigSchema.parse({
       driver,
       getUpgradeWebSocket: () => upgradeWebSocket,
       inspector: {
@@ -4247,12 +4418,12 @@ async function createTestRuntime(registryPath, driverFactory) {
       }
     });
     const managerDriver = driver.manager(registry.config, config);
-    const client = _chunkD6PCH7FRcjs.createClientWithDriver.call(void 0, 
+    const client = _chunk4SHILYS5cjs.createClientWithDriver.call(void 0, 
       managerDriver,
-      _chunkJMLTKMJ7cjs.ClientConfigSchema.parse({})
+      _chunkD3SLADUDcjs.ClientConfigSchema.parse({})
     );
-    _chunkXSDSNHSEcjs.configureInspectorAccessToken.call(void 0, config, managerDriver);
-    const { router } = _chunkXYK5PY3Bcjs.createManagerRouter.call(void 0, 
+    _chunkYC5DUHPMcjs.configureInspectorAccessToken.call(void 0, config, managerDriver);
+    const { router } = _chunkFVAKREFBcjs.createManagerRouter.call(void 0, 
       registry.config,
       config,
       managerDriver,
@@ -4261,7 +4432,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-    const port = await _chunkHNYF4T36cjs.getPort.call(void 0, );
+    const port = await _chunkCHLZBSI2cjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",