rivetkit 2.0.5 → 2.0.7-rc.1

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

@@ -1,34 +1,46 @@
 "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 _chunkFGFT4FVXcjs = require('../chunk-FGFT4FVX.cjs');
+var _chunkTZGUSEIJcjs = require('../chunk-TZGUSEIJ.cjs');
 
 
-var _chunkD7NWUCRKcjs = require('../chunk-D7NWUCRK.cjs');
 
+var _chunk3Y45CIF4cjs = require('../chunk-3Y45CIF4.cjs');
 
 
 
 
-var _chunkMRZS2J4Xcjs = require('../chunk-MRZS2J4X.cjs');
+var _chunkG4ABMAQYcjs = require('../chunk-G4ABMAQY.cjs');
 
 
+var _chunk6OVKCDSHcjs = require('../chunk-6OVKCDSH.cjs');
 
-var _chunkLZIBTLEYcjs = require('../chunk-LZIBTLEY.cjs');
 
 
-var _chunkPHSQJ6QIcjs = require('../chunk-PHSQJ6QI.cjs');
+var _chunk5ZOHIKWGcjs = require('../chunk-5ZOHIKWG.cjs');
+require('../chunk-B3TLRM4Q.cjs');
 
 
-var _chunkRM2SVURRcjs = require('../chunk-RM2SVURR.cjs');
+var _chunkK4ENQCC4cjs = require('../chunk-K4ENQCC4.cjs');
 
 
+var _chunkDFS77KAAcjs = require('../chunk-DFS77KAA.cjs');
 
 
-var _chunkIRMBWX36cjs = require('../chunk-IRMBWX36.cjs');
 
 
-var _chunk5YTI25C3cjs = require('../chunk-5YTI25C3.cjs');
-require('../chunk-WADSS5X4.cjs');
+
+
+
+
+
+
+var _chunkSAZCNSVYcjs = require('../chunk-SAZCNSVY.cjs');
+
+
+var _chunk3MBP4WNCcjs = require('../chunk-3MBP4WNC.cjs');
+
+
+var _chunk6EUWRXLTcjs = require('../chunk-6EUWRXLT.cjs');
 
 
 
@@ -43,7 +55,7 @@ var _vitest = require('vitest');
 
 // src/driver-test-suite/log.ts
 function logger() {
-  return _chunk5YTI25C3cjs.getLogger.call(void 0, "test-suite");
+  return _chunk3MBP4WNCcjs.getLogger.call(void 0, "test-suite");
 }
 
 // src/driver-test-suite/tests/action-features.ts
@@ -94,13 +106,14 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
       logger().debug({ msg: "rewriting http url", from: oldUrl, to: url });
       const headers = new Headers(actorRequest.headers);
-      headers.set(_chunkIRMBWX36cjs.HEADER_ACTOR_ID, actorId);
+      headers.set(_chunkSAZCNSVYcjs.HEADER_ACTOR_ID, actorId);
       const response = await fetch(
         new Request(url, {
           method: actorRequest.method,
           headers,
           body: actorRequest.body,
-          signal: actorRequest.signal
+          signal: actorRequest.signal,
+          duplex: "half"
         })
       );
       if (!response.ok && ((_a = response.headers.get("content-type")) == null ? void 0 : _a.includes("application/json"))) {
@@ -109,7 +122,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
           const errorData = await clonedResponse.json();
           if (errorData.error) {
             if (typeof errorData.error === "object") {
-              throw new (0, _chunkMRZS2J4Xcjs.ActorError)(
+              throw new (0, _chunk5ZOHIKWGcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -117,7 +130,7 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkMRZS2J4Xcjs.ActorError)) {
+          if (!(e instanceof _chunk5ZOHIKWGcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -125,38 +138,46 @@ function createTestInlineClientDriver(endpoint, encoding, transport) {
       }
       return response;
     },
-    async openWebSocket(path, actorId, encoding2, params) {
-      const WebSocket2 = await _chunkPHSQJ6QIcjs.importWebSocket.call(void 0, );
+    async openWebSocket(path, actorId, encoding2, params, connId, connToken) {
+      const WebSocket2 = await _chunkK4ENQCC4cjs.importWebSocket.call(void 0, );
       const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-      logger().debug({
-        msg: "creating websocket connection via test inline driver"
-      });
       const wsUrl = new URL(
         `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      wsUrl.searchParams.set("path", normalizedPath);
-      wsUrl.searchParams.set("actorId", actorId);
-      if (params !== void 0)
-        wsUrl.searchParams.set("params", JSON.stringify(params));
-      wsUrl.searchParams.set("encodingKind", encoding2);
+      logger().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}${wsUrl.search}`;
+      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
       logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
-      const ws = new WebSocket2(finalWsUrl, [
-        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
-        "rivetkit"
-      ]);
+      const protocols = [];
+      protocols.push(`${_chunkSAZCNSVYcjs.WS_PROTOCOL_TARGET}actor`);
+      protocols.push(`${_chunkSAZCNSVYcjs.WS_PROTOCOL_ACTOR}${actorId}`);
+      protocols.push(`${_chunkSAZCNSVYcjs.WS_PROTOCOL_ENCODING}${encoding2}`);
+      protocols.push(`${_chunkSAZCNSVYcjs.WS_PROTOCOL_TRANSPORT}${transport}`);
+      protocols.push(
+        `${_chunkSAZCNSVYcjs.WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`
+      );
+      if (params !== void 0) {
+        protocols.push(
+          `${_chunkSAZCNSVYcjs.WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+        );
+      }
+      const ws = new WebSocket2(finalWsUrl, protocols);
       return ws;
     },
     async proxyRequest(c, actorRequest, actorId) {
       return await this.sendRequest(actorId, actorRequest);
     },
-    proxyWebSocket(_c, _path, _actorId, _encoding, _params, _authData) {
+    proxyWebSocket(_c, _path, _actorId, _encoding, _params) {
       throw "UNIMPLEMENTED";
     },
     displayInformation() {
       return { name: "Test Inline", properties: {} };
-    }
+    },
+    // TODO:
+    getOrCreateInspectorAccessToken: () => ""
     // action: async <Args extends Array<unknown> = unknown[], Response = unknown>(
     // 	_c: HonoContext | undefined,
     // 	actorQuery: ActorQuery,
@@ -492,7 +513,8 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
       transport,
       method,
       args
-    })
+    }),
+    duplex: "half"
   });
   if (!response.ok) {
     throw new Error(`Failed to call inline ${method}: ${response.statusText}`);
@@ -504,14 +526,14 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkMRZS2J4Xcjs.ActorError)(
+    throw new (0, _chunk5ZOHIKWGcjs.ActorError)(
       callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunkIRMBWX36cjs.assertUnreachable.call(void 0, callResponse);
+    _chunkSAZCNSVYcjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -526,21 +548,25 @@ async function setupDriverTest(c, driverTestConfig) {
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkD7NWUCRKcjs.createClient.call(void 0, {
+    client = _chunk6OVKCDSHcjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
+    const transport = _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"));
     const managerDriver = createTestInlineClientDriver(
       endpoint,
       "bare",
-      _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"))
+      transport
     );
-    client = _chunkMRZS2J4Xcjs.createClientWithDriver.call(void 0, managerDriver);
+    const runConfig = _chunkDFS77KAAcjs.RunConfigSchema.parse({
+      transport
+    });
+    client = _chunk5ZOHIKWGcjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkIRMBWX36cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkSAZCNSVYcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -688,17 +714,19 @@ function runActorConnTests(driverTestConfig) {
         const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
         const connection = handle.connect();
         const receivedEvents = [];
-        const receivedEventsPromise = new Promise((resolve) => {
-          connection.on("newCount", (count) => {
-            receivedEvents.push(count);
-            if (receivedEvents.includes(1) && receivedEvents.includes(6) && receivedEvents.includes(9))
-              resolve(void 0);
-          });
+        connection.on("newCount", (count) => {
+          receivedEvents.push(count);
+        });
+        await _vitest.vi.waitFor(async () => {
+          await connection.setCount(1);
+          _vitest.expect.call(void 0, receivedEvents).includes(1);
+        });
+        await handle.setCount(2);
+        await handle.setCount(3);
+        await _vitest.vi.waitFor(() => {
+          _vitest.expect.call(void 0, receivedEvents).includes(2);
+          _vitest.expect.call(void 0, receivedEvents).includes(3);
         });
-        await connection.increment(1);
-        await handle.increment(5);
-        await handle.increment(3);
-        await receivedEventsPromise;
         await connection.dispose();
       });
       _vitest.test.call(void 0, "should receive events via broadcast", async (c) => {
@@ -709,10 +737,15 @@ function runActorConnTests(driverTestConfig) {
         connection.on("newCount", (count) => {
           receivedEvents.push(count);
         });
-        await connection.increment(5);
-        await connection.increment(3);
-        _vitest.expect.call(void 0, receivedEvents).toContain(5);
-        _vitest.expect.call(void 0, receivedEvents).toContain(8);
+        await _vitest.vi.waitFor(
+          async () => {
+            await connection.setCount(5);
+            await connection.setCount(8);
+            _vitest.expect.call(void 0, receivedEvents).toContain(5);
+            _vitest.expect.call(void 0, receivedEvents).toContain(8);
+          },
+          { timeout: 1e4 }
+        );
         await connection.dispose();
       });
       _vitest.test.call(void 0, "should handle one-time events with once()", async (c) => {
@@ -725,8 +758,10 @@ function runActorConnTests(driverTestConfig) {
         });
         await connection.increment(5);
         await connection.increment(3);
-        _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
-        _vitest.expect.call(void 0, receivedEvents).not.toContain(8);
+        await _vitest.vi.waitFor(() => {
+          _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
+          _vitest.expect.call(void 0, receivedEvents).not.toContain(8);
+        });
         await connection.dispose();
       });
       _vitest.test.call(void 0, "should unsubscribe from events", async (c) => {
@@ -737,10 +772,12 @@ function runActorConnTests(driverTestConfig) {
         const unsubscribe = connection.on("newCount", (count) => {
           receivedEvents.push(count);
         });
-        await connection.increment(5);
+        await _vitest.vi.waitFor(async () => {
+          await connection.setCount(5);
+          _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
+        });
         unsubscribe();
-        await connection.increment(3);
-        _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
+        await connection.setCount(8);
         _vitest.expect.call(void 0, receivedEvents).not.toContain(8);
         await connection.dispose();
       });
@@ -766,7 +803,9 @@ function runActorConnTests(driverTestConfig) {
       });
     });
     _vitest.describe.call(void 0, "Lifecycle Hooks", () => {
-      _vitest.test.call(void 0, "should trigger lifecycle hooks", async (c) => {
+      _vitest.test.skipIf(
+        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
+      )("should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -778,81 +817,30 @@ function runActorConnTests(driverTestConfig) {
         const events = await connection.getEvents();
         _vitest.expect.call(void 0, events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
         await connection.dispose();
-        const handle = client.counterWithLifecycle.getOrCreate([
-          "test-lifecycle"
-        ]);
-        const finalEvents = await handle.getEvents();
-        _vitest.expect.call(void 0, finalEvents).toBeOneOf([
-          // Still active
-          ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
-          // Went to sleep and woke back up
-          [
-            "onStart",
-            "onBeforeConnect",
-            "onConnect",
-            "onDisconnect",
-            "onStart"
-          ]
-        ]);
-      });
-    });
-    _vitest.describe.call(void 0, "Connection Liveness", () => {
-      _vitest.test.skip("should return correct liveness status for connections", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.connLivenessActor.getOrCreate([
-          "test-liveness-status"
-        ]);
-        const connA = handle.connect();
-        const connB = handle.connect();
-        const connAId = await connA.getConnectionId();
-        const connBId = await connB.getConnectionId();
-        await connA.increment(5);
-        await connB.increment(5);
-        const counter = await handle.getCounter();
-        _vitest.expect.call(void 0, counter).toBe(10);
-        const connectionsStatusBeforeKill = await handle.getWsConnectionsLiveness();
-        _vitest.expect.call(void 0, connectionsStatusBeforeKill).toHaveLength(2);
-        _vitest.expect.call(void 0, connectionsStatusBeforeKill).toContainEqual(
-          _vitest.expect.objectContaining({
-            id: connAId,
-            status: "connected",
-            lastSeen: FAKE_TIME.getTime()
-          })
-        );
-        _vitest.expect.call(void 0, connectionsStatusBeforeKill).toContainEqual(
-          _vitest.expect.objectContaining({
-            id: connBId,
-            status: "connected",
-            lastSeen: FAKE_TIME.getTime()
-          })
-        );
-        await handle.kill(connAId);
-        const connectionsStatusAfterKill = await handle.getWsConnectionsLiveness();
-        _vitest.expect.call(void 0, connectionsStatusAfterKill).toEqual(
-          _vitest.expect.arrayContaining([
-            _vitest.expect.objectContaining({
-              id: connAId,
-              status: "reconnecting",
-              lastSeen: FAKE_TIME.getTime()
-            }),
-            _vitest.expect.objectContaining({
-              id: connBId,
-              status: "connected",
-              lastSeen: FAKE_TIME.getTime()
-            })
-          ])
-        );
-        await waitFor(driverTestConfig, 5e3);
-        const connectionsStatusAfterCleanup = await handle.getWsConnectionsLiveness();
-        _vitest.expect.call(void 0, connectionsStatusAfterCleanup).not.toContainEqual(
-          _vitest.expect.objectContaining({
-            id: connAId
-          })
-        );
-        _vitest.expect.call(void 0, connectionsStatusAfterCleanup).toContainEqual(
-          _vitest.expect.objectContaining({
-            id: connBId
-          })
+        await _vitest.vi.waitFor(
+          async () => {
+            const handle = client.counterWithLifecycle.getOrCreate([
+              "test-lifecycle"
+            ]);
+            const finalEvents = await handle.getEvents();
+            _vitest.expect.call(void 0, finalEvents).toBeOneOf([
+              // Still active
+              ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
+              // Went to sleep and woke back up
+              [
+                "onStart",
+                "onBeforeConnect",
+                "onConnect",
+                "onDisconnect",
+                "onStart"
+              ]
+            ]);
+          },
+          // NOTE: High timeout required for Cloudflare Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
         );
       });
     });
@@ -940,21 +928,57 @@ function runActorConnStateTests(driverTestConfig) {
       });
     });
     _vitest.describe.call(void 0, "Connection Lifecycle", () => {
-      _vitest.test.call(void 0, "should track connection and disconnection events", async (c) => {
+      _vitest.test.skipIf(
+        driverTestConfig.transport === "sse" && driverTestConfig.clientType === "inline"
+      )("should track connection and disconnection events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
-        const handle = client.connStateActor.getOrCreate();
-        const conn = handle.connect();
+        const debugHandle = client.connStateActor.getOrCreate(void 0, {
+          params: { noCount: true }
+        });
+        const conn = client.connStateActor.getOrCreate().connect();
         const connState = await conn.getConnectionState();
-        const connectionIds = await conn.getConnectionIds();
-        _vitest.expect.call(void 0, connectionIds).toContain(connState.id);
-        const initialDisconnections = await conn.getDisconnectionCount();
+        await _vitest.vi.waitFor(async () => {
+          const connectionIds = await debugHandle.getConnectionIds();
+          _vitest.expect.call(void 0, connectionIds).toContain(connState.id);
+        });
+        await _vitest.vi.waitFor(async () => {
+          const disconnects = await debugHandle.getDisconnectionCount();
+          _vitest.expect.call(void 0, disconnects).toBe(0);
+        });
         await conn.dispose();
-        const newConn = handle.connect();
+        await _vitest.vi.waitFor(
+          async () => {
+            console.log("disconnects before");
+            const disconnects = await debugHandle.getDisconnectionCount();
+            console.log("disconnects", disconnects);
+            _vitest.expect.call(void 0, disconnects).toBe(1);
+          },
+          // SSE takes a long time to disconnect on CF Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
+        );
+        const newConn = client.connStateActor.getOrCreate().connect();
         await _vitest.vi.waitFor(async () => {
-          const newDisconnections = await newConn.getDisconnectionCount();
-          _vitest.expect.call(void 0, newDisconnections).toBeGreaterThan(initialDisconnections);
+          const connectionIds = await debugHandle.getConnectionIds();
+          console.log("conn ids", connectionIds);
+          _vitest.expect.call(void 0, connectionIds.length).toBe(1);
         });
         await newConn.dispose();
+        await _vitest.vi.waitFor(
+          async () => {
+            console.log("A");
+            const disconnects = await debugHandle.getDisconnectionCount();
+            console.log(`B ${disconnects}`);
+            _vitest.expect.call(void 0, disconnects).toBe(2);
+          },
+          // SSE takes a long time to disconnect on CF Workers
+          {
+            timeout: 1e4,
+            interval: 100
+          }
+        );
       });
       _vitest.test.call(void 0, "should update connection state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
@@ -985,14 +1009,16 @@ function runActorConnStateTests(driverTestConfig) {
         conn2.on("directMessage", (data) => {
           receivedMessages.push(data);
         });
-        const success = await conn1.sendToConnection(
-          state2.id,
-          "Hello from conn1"
-        );
-        _vitest.expect.call(void 0, success).toBe(true);
-        _vitest.expect.call(void 0, receivedMessages.length).toBe(1);
-        _vitest.expect.call(void 0, receivedMessages[0].from).toBe(state1.id);
-        _vitest.expect.call(void 0, receivedMessages[0].message).toBe("Hello from conn1");
+        await _vitest.vi.waitFor(async () => {
+          const success = await conn1.sendToConnection(
+            state2.id,
+            "Hello from conn1"
+          );
+          _vitest.expect.call(void 0, success).toBe(true);
+          _vitest.expect.call(void 0, receivedMessages.length).toBe(1);
+          _vitest.expect.call(void 0, receivedMessages[0].from).toBe(state1.id);
+          _vitest.expect.call(void 0, receivedMessages[0].message).toBe("Hello from conn1");
+        });
         await conn1.dispose();
         await conn2.dispose();
       });
@@ -1071,7 +1097,7 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 500;
-var sleep = _chunkMRZS2J4Xcjs.actor.call(void 0, {
+var sleep = _chunk3Y45CIF4cjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1097,7 +1123,7 @@ var sleep = _chunkMRZS2J4Xcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunkMRZS2J4Xcjs.actor.call(void 0, {
+var sleepWithLongRpc = _chunk3Y45CIF4cjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -1112,7 +1138,7 @@ var sleepWithLongRpc = _chunkMRZS2J4Xcjs.actor.call(void 0, {
     },
     longRunningRpc: async (c) => {
       c.log.info("starting long running rpc");
-      c.vars.longRunningResolve = Promise.withResolvers();
+      c.vars.longRunningResolve = _chunk6EUWRXLTcjs.promiseWithResolvers.call(void 0, );
       c.broadcast("waiting");
       await c.vars.longRunningResolve.promise;
       c.log.info("finished long running rpc");
@@ -1126,7 +1152,7 @@ var sleepWithLongRpc = _chunkMRZS2J4Xcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunkMRZS2J4Xcjs.actor.call(void 0, {
+var sleepWithRawHttp = _chunk3Y45CIF4cjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1161,7 +1187,7 @@ var sleepWithRawHttp = _chunkMRZS2J4Xcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunkMRZS2J4Xcjs.actor.call(void 0, {
+var sleepWithRawWebSocket = _chunk3Y45CIF4cjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1224,7 +1250,7 @@ var sleepWithRawWebSocket = _chunkMRZS2J4Xcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunkMRZS2J4Xcjs.actor.call(void 0, {
+var sleepWithNoSleepOption = _chunk3Y45CIF4cjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1439,7 +1465,6 @@ function runActorSleepTests(driverTestConfig) {
       _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
       _vitest.expect.call(void 0, counts.startCount).toBe(1);
       ws.close();
-      await new Promise((resolve) => setTimeout(resolve, 100));
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
@@ -1935,7 +1960,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1949,7 +1974,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         await client.counter.create(["test-actor-1"]);
         await client.counter.create(["test-actor-2"]);
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1972,7 +1997,7 @@ function runActorInspectorTests(driverTestConfig) {
         const actorKey2 = ["test-cursor-2"];
         await client.counter.create(actorKey1);
         await client.counter.create(actorKey2);
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1997,7 +2022,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2009,7 +2034,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2033,7 +2058,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2051,7 +2076,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-get-by-id"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2065,7 +2090,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2081,7 +2106,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2103,10 +2128,10 @@ 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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2118,10 +2143,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-ping"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2136,10 +2161,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state"]);
         const actorId = await handle.resolve();
         await handle.increment(5);
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2158,10 +2183,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-state-replace"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2183,10 +2208,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state-patch"]);
         const actorId = await handle.resolve();
         await handle.increment(3);
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2217,10 +2242,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2242,10 +2267,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2268,10 +2293,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2296,10 +2321,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-rpcs"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2317,10 +2342,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-db"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2341,10 +2366,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-db-query"]);
         const actorId = await handle.resolve();
-        const http = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkG4ABMAQYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkSAZCNSVYcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2507,6 +2532,103 @@ 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) {
@@ -3549,29 +3671,6 @@ function runRawWebSocketTests(driverTestConfig) {
       _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    _vitest.test.call(void 0, "should pass connection parameters through subprotocols", async (c) => {
-      const { client } = await setupDriverTest(c, driverTestConfig);
-      const testParams = { userId: "test123", role: "admin" };
-      const actor2 = client.rawWebSocketActor.getOrCreate(["params"], {
-        params: testParams
-      });
-      const ws = await actor2.websocket();
-      await new Promise((resolve) => {
-        ws.addEventListener("open", () => resolve(), { once: true });
-      });
-      ws.send(JSON.stringify({ type: "getAuthData" }));
-      const response = await new Promise((resolve, reject) => {
-        ws.addEventListener("message", (event) => {
-          const data = JSON.parse(event.data);
-          if (data.type === "authData") {
-            resolve(data);
-          }
-        });
-        ws.addEventListener("close", reject);
-      });
-      _vitest.expect.call(void 0, response).toBeDefined();
-      ws.close();
-    });
     _vitest.test.call(void 0, "should handle connection close properly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["close-test"]);
@@ -3777,15 +3876,18 @@ function runDriverTests(driverTestConfigPartial) {
       clientType
     };
     _vitest.describe.call(void 0, `client type (${clientType})`, () => {
+      var _a;
       runActorDriverTests(driverTestConfig);
       runManagerDriverTests(driverTestConfig);
-      for (const transport of ["websocket", "sse"]) {
+      const transports = ((_a = driverTestConfig.skip) == null ? void 0 : _a.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 });
         });
@@ -3828,7 +3930,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     };
   } else {
     let upgradeWebSocket;
-    const config = _chunkRM2SVURRcjs.RunConfigSchema.parse({
+    const config = _chunkDFS77KAAcjs.RunConfigSchema.parse({
       driver,
       getUpgradeWebSocket: () => upgradeWebSocket,
       inspector: {
@@ -3837,15 +3939,16 @@ async function createTestRuntime(registryPath, driverFactory) {
       }
     });
     const managerDriver = driver.manager(registry.config, config);
-    const { router } = _chunkMRZS2J4Xcjs.createManagerRouter.call(void 0, 
+    _chunkG4ABMAQYcjs.configureInspectorAccessToken.call(void 0, config, managerDriver);
+    const { router } = _chunk3Y45CIF4cjs.createManagerRouter.call(void 0, 
       registry.config,
       config,
       managerDriver,
-      false
+      void 0
     );
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-    const port = await _chunkFGFT4FVXcjs.getPort.call(void 0, );
+    const port = await _chunkTZGUSEIJcjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",