rivetkit 2.0.2 → 2.0.4

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

@@ -0,0 +1,3411 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkIH6CKNDWcjs = require('../chunk-IH6CKNDW.cjs');
+
+
+var _chunk4R73YDN3cjs = require('../chunk-4R73YDN3.cjs');
+
+
+
+var _chunkVO7ZRVVDcjs = require('../chunk-VO7ZRVVD.cjs');
+
+
+
+var _chunkLWNKVZG5cjs = require('../chunk-LWNKVZG5.cjs');
+require('../chunk-QNNXFOQV.cjs');
+
+
+var _chunkWHBPJNGWcjs = require('../chunk-WHBPJNGW.cjs');
+
+
+
+var _chunkGICQ3YCUcjs = require('../chunk-GICQ3YCU.cjs');
+
+
+var _chunk4CXBCT26cjs = require('../chunk-4CXBCT26.cjs');
+require('../chunk-6LJT3QRL.cjs');
+
+
+
+var _chunkSBHHJ6QScjs = require('../chunk-SBHHJ6QS.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 _chunk4CXBCT26cjs.getLogger.call(void 0, "test-suite");
+}
+
+// src/driver-test-suite/tests/action-features.ts
+
+
+// src/driver-test-suite/utils.ts
+var _path = require('path');
+
+var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
+async function setupDriverTest(c, driverTestConfig) {
+  if (!driverTestConfig.useRealTimers) {
+    _vitest.vi.useFakeTimers();
+    _vitest.vi.setSystemTime(FAKE_TIME);
+  }
+  const projectPath = _path.resolve.call(void 0, __dirname, "../../fixtures/driver-test-suite");
+  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start(projectPath);
+  c.onTestFinished(cleanup);
+  let client;
+  if (driverTestConfig.clientType === "http") {
+    client = _chunk4R73YDN3cjs.createClient.call(void 0, {
+      endpoint,
+      namespace,
+      runnerName,
+      transport: driverTestConfig.transport
+    });
+  } else if (driverTestConfig.clientType === "inline") {
+    throw "TODO";
+  } else {
+    _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+  }
+  if (!driverTestConfig.HACK_skipCleanupNet) {
+    c.onTestFinished(async () => await client.dispose());
+  }
+  return {
+    client,
+    endpoint
+  };
+}
+async function waitFor(driverTestConfig, ms) {
+  if (driverTestConfig.useRealTimers) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  } else {
+    _vitest.vi.advanceTimersByTime(ms);
+    return Promise.resolve();
+  }
+}
+
+// src/driver-test-suite/tests/action-features.ts
+function runActionFeaturesTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Action Features", () => {
+    _vitest.describe.call(void 0, "Action Timeouts", () => {
+      const usesFakeTimers = !driverTestConfig.useRealTimers;
+      _vitest.test.call(void 0, "should timeout actions that exceed the configured timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const quickResult = await client.shortTimeoutActor.getOrCreate().quickAction();
+        _vitest.expect.call(void 0, quickResult).toBe("quick response");
+        await _vitest.expect.call(void 0, 
+          client.shortTimeoutActor.getOrCreate().slowAction()
+        ).rejects.toThrow("Action timed out");
+      });
+      _vitest.test.call(void 0, "should respect the default timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const result = await client.defaultTimeoutActor.getOrCreate().normalAction();
+        _vitest.expect.call(void 0, result).toBe("normal response");
+      });
+      _vitest.test.call(void 0, "non-promise action results should not be affected by timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const result = await client.syncTimeoutActor.getOrCreate().syncAction();
+        _vitest.expect.call(void 0, result).toBe("sync response");
+      });
+      _vitest.test.call(void 0, "should allow configuring different timeouts for different actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        await _vitest.expect.call(void 0, 
+          client.shortTimeoutActor.getOrCreate().slowAction()
+        ).rejects.toThrow("Action timed out");
+        const result = await client.longTimeoutActor.getOrCreate().delayedAction();
+        _vitest.expect.call(void 0, result).toBe("delayed response");
+      });
+    });
+    _vitest.describe.call(void 0, "Action Sync & Async", () => {
+      _vitest.test.call(void 0, "should support synchronous actions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.syncActionActor.getOrCreate();
+        let result = await instance.increment(5);
+        _vitest.expect.call(void 0, result).toBe(5);
+        result = await instance.increment(3);
+        _vitest.expect.call(void 0, result).toBe(8);
+        const info = await instance.getInfo();
+        _vitest.expect.call(void 0, info.currentValue).toBe(8);
+        _vitest.expect.call(void 0, typeof info.timestamp).toBe("number");
+        await instance.reset();
+        result = await instance.increment(0);
+        _vitest.expect.call(void 0, result).toBe(0);
+      });
+      _vitest.test.call(void 0, "should support asynchronous actions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.asyncActionActor.getOrCreate();
+        const result = await instance.delayedIncrement(5);
+        _vitest.expect.call(void 0, result).toBe(5);
+        const data = await instance.fetchData("test-123");
+        _vitest.expect.call(void 0, data.id).toBe("test-123");
+        _vitest.expect.call(void 0, typeof data.timestamp).toBe("number");
+        const success = await instance.asyncWithError(false);
+        _vitest.expect.call(void 0, success).toBe("Success");
+        try {
+          await instance.asyncWithError(true);
+          _vitest.expect.fail("did not error");
+        } catch (error) {
+          _vitest.expect.call(void 0, error.message).toBe("Intentional error");
+        }
+      });
+      _vitest.test.call(void 0, "should handle promises returned from actions correctly", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.promiseActor.getOrCreate();
+        const resolvedValue = await instance.resolvedPromise();
+        _vitest.expect.call(void 0, resolvedValue).toBe("resolved value");
+        const delayedValue = await instance.delayedPromise();
+        _vitest.expect.call(void 0, delayedValue).toBe("delayed value");
+        await _vitest.expect.call(void 0, instance.rejectedPromise()).rejects.toThrow(
+          "promised rejection"
+        );
+        const results = await instance.getResults();
+        _vitest.expect.call(void 0, results).toContain("delayed");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-conn.ts
+
+function runActorConnTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Connection Tests", () => {
+    _vitest.describe.call(void 0, "Connection Methods", () => {
+      _vitest.test.call(void 0, "should connect using .get().connect()", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        await client.counter.create(["test-get"]);
+        const handle = client.counter.get(["test-get"]);
+        const connection = handle.connect();
+        const count = await connection.increment(5);
+        _vitest.expect.call(void 0, count).toBe(5);
+        await connection.dispose();
+      });
+      _vitest.test.call(void 0, "should connect using .getForId().connect()", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-get-for-id"]);
+        await handle.increment(3);
+        const actorId = await handle.resolve();
+        const idHandle = client.counter.getForId(actorId);
+        const connection = idHandle.connect();
+        const count = await connection.getCount();
+        _vitest.expect.call(void 0, count).toBe(3);
+        await connection.dispose();
+      });
+      _vitest.test.call(void 0, "should connect using .getOrCreate().connect()", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-get-or-create"]);
+        const connection = handle.connect();
+        const count = await connection.increment(7);
+        _vitest.expect.call(void 0, count).toBe(7);
+        await connection.dispose();
+      });
+      _vitest.test.call(void 0, "should connect using (await create()).connect()", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-create"]);
+        const connection = handle.connect();
+        const count = await connection.increment(9);
+        _vitest.expect.call(void 0, count).toBe(9);
+        await connection.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Event Communication", () => {
+      _vitest.test.call(void 0, "should mix RPC calls and WebSocket events", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
+        const connection = handle.connect();
+        const receivedEvents = [];
+        const receivedEventsPromise = new Promise((resolve2) => {
+          connection.on("newCount", (count) => {
+            receivedEvents.push(count);
+            if (receivedEvents.includes(1) && receivedEvents.includes(6) && receivedEvents.includes(9))
+              resolve2(void 0);
+          });
+        });
+        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) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-broadcast"]);
+        const connection = handle.connect();
+        const receivedEvents = [];
+        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 connection.dispose();
+      });
+      _vitest.test.call(void 0, "should handle one-time events with once()", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-once"]);
+        const connection = handle.connect();
+        const receivedEvents = [];
+        connection.once("newCount", (count) => {
+          receivedEvents.push(count);
+        });
+        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 connection.dispose();
+      });
+      _vitest.test.call(void 0, "should unsubscribe from events", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-unsubscribe"]);
+        const connection = handle.connect();
+        const receivedEvents = [];
+        const unsubscribe = connection.on("newCount", (count) => {
+          receivedEvents.push(count);
+        });
+        await connection.increment(5);
+        unsubscribe();
+        await connection.increment(3);
+        _vitest.expect.call(void 0, receivedEvents).toEqual([5]);
+        _vitest.expect.call(void 0, receivedEvents).not.toContain(8);
+        await connection.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Connection Parameters", () => {
+      _vitest.test.call(void 0, "should pass connection parameters", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle1 = client.counterWithParams.getOrCreate(["test-params"], {
+          params: { name: "user1" }
+        });
+        const handle2 = client.counterWithParams.getOrCreate(["test-params"], {
+          params: { name: "user2" }
+        });
+        const conn1 = handle1.connect();
+        const conn2 = handle2.connect();
+        await conn1.getInitializers();
+        await conn2.getInitializers();
+        const initializers = await conn1.getInitializers();
+        _vitest.expect.call(void 0, initializers).toContain("user1");
+        _vitest.expect.call(void 0, initializers).toContain("user2");
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Lifecycle Hooks", () => {
+      _vitest.test.call(void 0, "should trigger lifecycle hooks", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const connHandle = client.counterWithLifecycle.getOrCreate(
+          ["test-lifecycle"],
+          {
+            params: { trackLifecycle: true }
+          }
+        );
+        const connection = connHandle.connect();
+        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
+          })
+        );
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-conn-state.ts
+
+function runActorConnStateTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Connection State Tests", () => {
+    _vitest.describe.call(void 0, "Connection State Initialization", () => {
+      _vitest.test.call(void 0, "should retrieve connection state", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const connection = client.connStateActor.getOrCreate().connect();
+        const connState = await connection.getConnectionState();
+        _vitest.expect.call(void 0, connState.id).toBeDefined();
+        _vitest.expect.call(void 0, connState.username).toBeDefined();
+        _vitest.expect.call(void 0, connState.role).toBeDefined();
+        _vitest.expect.call(void 0, connState.counter).toBeDefined();
+        _vitest.expect.call(void 0, connState.createdAt).toBeDefined();
+        await connection.dispose();
+      });
+      _vitest.test.call(void 0, "should initialize connection state with custom parameters", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const connection = client.connStateActor.getOrCreate([], {
+          params: {
+            username: "testuser",
+            role: "admin"
+          }
+        }).connect();
+        const connState = await connection.getConnectionState();
+        _vitest.expect.call(void 0, connState.username).toBe("testuser");
+        _vitest.expect.call(void 0, connState.role).toBe("admin");
+        await connection.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Connection State Management", () => {
+      _vitest.test.call(void 0, "should maintain unique state for each connection", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const conn1 = client.connStateActor.getOrCreate([], {
+          params: { username: "user1" }
+        }).connect();
+        const conn2 = client.connStateActor.getOrCreate([], {
+          params: { username: "user2" }
+        }).connect();
+        await conn1.incrementConnCounter(5);
+        await conn2.incrementConnCounter(10);
+        const state1 = await conn1.getConnectionState();
+        const state2 = await conn2.getConnectionState();
+        _vitest.expect.call(void 0, state1.counter).toBe(5);
+        _vitest.expect.call(void 0, state2.counter).toBe(10);
+        _vitest.expect.call(void 0, state1.username).toBe("user1");
+        _vitest.expect.call(void 0, state2.username).toBe("user2");
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+      _vitest.test.call(void 0, "should track connections in shared state", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.connStateActor.getOrCreate();
+        const conn1 = handle.connect();
+        const conn2 = handle.connect();
+        await conn1.getConnectionState();
+        await conn2.getConnectionState();
+        const state1 = await conn1.getConnectionState();
+        const connectionIds = await conn1.getConnectionIds();
+        _vitest.expect.call(void 0, connectionIds.length).toBeGreaterThanOrEqual(2);
+        _vitest.expect.call(void 0, connectionIds).toContain(state1.id);
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+      _vitest.test.call(void 0, "should identify different connections in the same actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.connStateActor.getOrCreate();
+        const conn1 = handle.connect();
+        const conn2 = handle.connect();
+        await conn1.getConnectionState();
+        await conn2.getConnectionState();
+        const allStates = await conn1.getAllConnectionStates();
+        _vitest.expect.call(void 0, allStates.length).toBeGreaterThanOrEqual(2);
+        const ids = allStates.map((state) => state.id);
+        const uniqueIds = [...new Set(ids)];
+        _vitest.expect.call(void 0, uniqueIds.length).toBe(ids.length);
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Connection Lifecycle", () => {
+      _vitest.test.call(void 0, "should track connection and disconnection events", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.connStateActor.getOrCreate();
+        const conn = handle.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 conn.dispose();
+        const newConn = handle.connect();
+        await _vitest.vi.waitFor(async () => {
+          const newDisconnections = await newConn.getDisconnectionCount();
+          _vitest.expect.call(void 0, newDisconnections).toBeGreaterThan(initialDisconnections);
+        });
+        await newConn.dispose();
+      });
+      _vitest.test.call(void 0, "should update connection state", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const conn = client.connStateActor.getOrCreate().connect();
+        const initialState = await conn.getConnectionState();
+        _vitest.expect.call(void 0, initialState.username).toBe("anonymous");
+        const updatedState = await conn.updateConnection({
+          username: "newname",
+          role: "moderator"
+        });
+        _vitest.expect.call(void 0, updatedState.username).toBe("newname");
+        _vitest.expect.call(void 0, updatedState.role).toBe("moderator");
+        const latestState = await conn.getConnectionState();
+        _vitest.expect.call(void 0, latestState.username).toBe("newname");
+        _vitest.expect.call(void 0, latestState.role).toBe("moderator");
+        await conn.dispose();
+      });
+    });
+    _vitest.describe.call(void 0, "Connection Communication", () => {
+      _vitest.test.call(void 0, "should send messages to specific connections", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.connStateActor.getOrCreate();
+        const conn1 = handle.connect();
+        const conn2 = handle.connect();
+        const state1 = await conn1.getConnectionState();
+        const state2 = await conn2.getConnectionState();
+        const receivedMessages = [];
+        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 conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-driver.ts
+
+
+// src/driver-test-suite/tests/actor-schedule.ts
+
+function runActorScheduleTests(driverTestConfig) {
+  var _a;
+  _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+    "Actor Schedule Tests",
+    () => {
+      _vitest.describe.call(void 0, "Scheduled Alarms", () => {
+        _vitest.test.call(void 0, "executes c.schedule.at() with specific timestamp", async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const scheduled = client.scheduled.getOrCreate();
+          const timestamp = Date.now() + 100;
+          await scheduled.scheduleTaskAt(timestamp);
+          await waitFor(driverTestConfig, 200);
+          const lastRun = await scheduled.getLastRun();
+          const scheduledCount = await scheduled.getScheduledCount();
+          _vitest.expect.call(void 0, lastRun).toBeGreaterThan(0);
+          _vitest.expect.call(void 0, scheduledCount).toBe(1);
+        });
+        _vitest.test.call(void 0, "executes c.schedule.after() with delay", async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const scheduled = client.scheduled.getOrCreate();
+          await scheduled.scheduleTaskAfter(100);
+          await waitFor(driverTestConfig, 200);
+          const lastRun = await scheduled.getLastRun();
+          const scheduledCount = await scheduled.getScheduledCount();
+          _vitest.expect.call(void 0, lastRun).toBeGreaterThan(0);
+          _vitest.expect.call(void 0, scheduledCount).toBe(1);
+        });
+        _vitest.test.call(void 0, "scheduled tasks persist across actor restarts", async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const scheduled = client.scheduled.getOrCreate();
+          await scheduled.scheduleTaskAfter(200);
+          await waitFor(driverTestConfig, 100);
+          const newInstance = client.scheduled.getOrCreate();
+          const initialCount = await newInstance.getScheduledCount();
+          _vitest.expect.call(void 0, initialCount).toBe(0);
+          await waitFor(driverTestConfig, 200);
+          const scheduledCount = await newInstance.getScheduledCount();
+          _vitest.expect.call(void 0, scheduledCount).toBe(1);
+        });
+        _vitest.test.call(void 0, "multiple scheduled tasks execute in order", async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const scheduled = client.scheduled.getOrCreate();
+          await scheduled.clearHistory();
+          await scheduled.scheduleTaskAfterWithId("first", 100);
+          await scheduled.scheduleTaskAfterWithId("second", 300);
+          await scheduled.scheduleTaskAfterWithId("third", 500);
+          await waitFor(driverTestConfig, 200);
+          const history1 = await scheduled.getTaskHistory();
+          _vitest.expect.call(void 0, history1).toEqual(["first"]);
+          await waitFor(driverTestConfig, 200);
+          const history2 = await scheduled.getTaskHistory();
+          _vitest.expect.call(void 0, history2).toEqual(["first", "second"]);
+          await waitFor(driverTestConfig, 200);
+          const history3 = await scheduled.getTaskHistory();
+          _vitest.expect.call(void 0, history3).toEqual(["first", "second", "third"]);
+        });
+      });
+    }
+  );
+}
+
+// src/driver-test-suite/tests/actor-sleep.ts
+
+
+// fixtures/driver-test-suite/sleep.ts
+var SLEEP_TIMEOUT = 500;
+var sleep = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+  state: { startCount: 0, sleepCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    },
+    setAlarm: async (c, duration) => {
+      await c.schedule.after(duration, "onAlarm");
+    },
+    onAlarm: (c) => {
+      c.log.info("alarm called");
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithLongRpc = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+  state: { startCount: 0, sleepCount: 0 },
+  createVars: () => ({}),
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    },
+    longRunningRpc: async (c) => {
+      c.log.info("starting long running rpc");
+      c.vars.longRunningResolve = Promise.withResolvers();
+      c.broadcast("waiting");
+      await c.vars.longRunningResolve.promise;
+      c.log.info("finished long running rpc");
+    },
+    finishLongRunningRpc: (c) => {
+      var _a;
+      return (_a = c.vars.longRunningResolve) == null ? void 0 : _a.resolve();
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawHttp = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+  state: { startCount: 0, sleepCount: 0, requestCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onFetch: async (c, request) => {
+    c.state.requestCount += 1;
+    const url = new URL(request.url);
+    if (url.pathname === "/long-request") {
+      const duration = parseInt(url.searchParams.get("duration") || "1000");
+      c.log.info({ msg: "starting long fetch request", duration });
+      await new Promise((resolve2) => setTimeout(resolve2, duration));
+      c.log.info("finished long fetch request");
+      return new Response(JSON.stringify({ completed: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        requestCount: c.state.requestCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawWebSocket = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+  state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onWebSocket: (c, websocket, opts) => {
+    c.state.connectionCount += 1;
+    c.log.info({
+      msg: "websocket connected",
+      connectionCount: c.state.connectionCount
+    });
+    websocket.send(
+      JSON.stringify({
+        type: "connected",
+        connectionCount: c.state.connectionCount
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      const data = event.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "getCounts") {
+            websocket.send(
+              JSON.stringify({
+                type: "counts",
+                startCount: c.state.startCount,
+                sleepCount: c.state.sleepCount,
+                connectionCount: c.state.connectionCount
+              })
+            );
+          } else if (parsed.type === "keepAlive") {
+            websocket.send(JSON.stringify({ type: "ack" }));
+          }
+        } catch (e2) {
+          websocket.send(data);
+        }
+      }
+    });
+    websocket.addEventListener("close", () => {
+      c.state.connectionCount -= 1;
+      c.log.info({
+        msg: "websocket disconnected",
+        connectionCount: c.state.connectionCount
+      });
+    });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        connectionCount: c.state.connectionCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithNoSleepOption = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+  state: { startCount: 0, sleepCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT,
+    noSleep: true
+  }
+});
+
+// src/driver-test-suite/tests/actor-sleep.ts
+function runActorSleepTests(driverTestConfig) {
+  var _a;
+  _vitest.describe.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    _vitest.test.call(void 0, "actor sleep persists state", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.triggerSleep();
+      await waitFor(driverTestConfig, 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "actor sleep persists state with connect", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate().connect();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.triggerSleep();
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, 100);
+      const sleepActor2 = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "actor automatically sleeps after timeout", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "actor automatically sleeps after timeout with connect", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate().connect();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      const sleepActor2 = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "rpc calls keep actor awake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "alarms keep actor awake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.setAlarm(SLEEP_TIMEOUT - 100);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+    });
+    _vitest.test.call(void 0, "alarms wake actors", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.setAlarm(SLEEP_TIMEOUT + 100);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "long running rpcs keep actor awake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithLongRpc.getOrCreate().connect();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      const waitPromise = new Promise(
+        (resolve2) => sleepActor.once("waiting", resolve2)
+      );
+      const longRunningPromise = sleepActor.longRunningRpc();
+      await waitPromise;
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      await sleepActor.finishLongRunningRpc();
+      await longRunningPromise;
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "active raw websockets keep actor awake", async (c) => {
+      const { client, endpoint: baseUrl } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
+      const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      const ws = await sleepActor.websocket();
+      await new Promise((resolve2, reject) => {
+        ws.onopen = () => resolve2();
+        ws.onerror = reject;
+      });
+      await new Promise((resolve2) => {
+        ws.onmessage = (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "connected") {
+            resolve2();
+          }
+        };
+      });
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      ws.send(JSON.stringify({ type: "getCounts" }));
+      const counts = await new Promise((resolve2) => {
+        ws.onmessage = (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "counts") {
+            resolve2(data);
+          }
+        };
+      });
+      _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
+      _vitest.expect.call(void 0, counts.startCount).toBe(1);
+      ws.close();
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "active raw fetch requests keep actor awake", async (c) => {
+      const { client, endpoint: baseUrl } = await setupDriverTest(
+        c,
+        driverTestConfig
+      );
+      const sleepActor = client.sleepWithRawHttp.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      const fetchDuration = SLEEP_TIMEOUT + 100;
+      const fetchPromise = sleepActor.fetch(
+        `long-request?duration=${fetchDuration}`
+      );
+      const response = await fetchPromise;
+      const result = await response.json();
+      _vitest.expect.call(void 0, result.completed).toBe(true);
+      {
+        const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+        _vitest.expect.call(void 0, requestCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(1);
+        _vitest.expect.call(void 0, startCount).toBe(2);
+      }
+    });
+    _vitest.test.call(void 0, "noSleep option disables sleeping", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        _vitest.expect.call(void 0, sleepCount).toBe(0);
+        _vitest.expect.call(void 0, startCount).toBe(1);
+      }
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-state.ts
+
+function runActorStateTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor State Tests", () => {
+    _vitest.describe.call(void 0, "State Persistence", () => {
+      _vitest.test.call(void 0, "persists state between actor instances", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counterInstance = client.counter.getOrCreate();
+        const initialCount = await counterInstance.increment(5);
+        _vitest.expect.call(void 0, initialCount).toBe(5);
+        const sameInstance = client.counter.getOrCreate();
+        const persistedCount = await sameInstance.increment(3);
+        _vitest.expect.call(void 0, persistedCount).toBe(8);
+      });
+      _vitest.test.call(void 0, "restores state after actor disconnect/reconnect", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counterInstance = client.counter.getOrCreate();
+        await counterInstance.increment(5);
+        const reconnectedInstance = client.counter.getOrCreate();
+        const persistedCount = await reconnectedInstance.increment(0);
+        _vitest.expect.call(void 0, persistedCount).toBe(5);
+      });
+      _vitest.test.call(void 0, "maintains separate state for different actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counterA = client.counter.getOrCreate(["counter-a"]);
+        await counterA.increment(5);
+        const counterB = client.counter.getOrCreate(["counter-b"]);
+        await counterB.increment(10);
+        const countA = await counterA.increment(0);
+        const countB = await counterB.increment(0);
+        _vitest.expect.call(void 0, countA).toBe(5);
+        _vitest.expect.call(void 0, countB).toBe(10);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-driver.ts
+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);
+  });
+}
+
+// src/driver-test-suite/tests/actor-error-handling.ts
+
+function runActorErrorHandlingTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Error Handling Tests", () => {
+    _vitest.describe.call(void 0, "UserError Handling", () => {
+      _vitest.test.call(void 0, "should handle simple UserError with message", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwSimpleError();
+          _vitest.expect.call(void 0, true).toBe(false);
+        } catch (error) {
+          _vitest.expect.call(void 0, error.message).toBe("Simple error message");
+          _vitest.expect.call(void 0, error.code).toBe("user_error");
+          _vitest.expect.call(void 0, error.metadata).toBeUndefined();
+        }
+      });
+      _vitest.test.call(void 0, "should handle detailed UserError with code and metadata", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwDetailedError();
+          _vitest.expect.call(void 0, true).toBe(false);
+        } catch (error) {
+          _vitest.expect.call(void 0, error.message).toBe("Detailed error message");
+          _vitest.expect.call(void 0, error.code).toBe("detailed_error");
+          _vitest.expect.call(void 0, error.metadata).toBeDefined();
+          _vitest.expect.call(void 0, error.metadata.reason).toBe("test");
+          _vitest.expect.call(void 0, error.metadata.timestamp).toBeDefined();
+        }
+      });
+    });
+    _vitest.describe.call(void 0, "Internal Error Handling", () => {
+      _vitest.test.call(void 0, "should convert internal errors to safe format", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwInternalError();
+          _vitest.expect.call(void 0, true).toBe(false);
+        } catch (error) {
+          if (driverTestConfig.clientType === "http") {
+            _vitest.expect.call(void 0, error.code).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
+            _vitest.expect.call(void 0, error.message).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_DESCRIPTION);
+          } else if (driverTestConfig.clientType === "inline") {
+            _vitest.expect.call(void 0, error.code).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
+            _vitest.expect.call(void 0, error.message).toBe("This is an internal error");
+          } else {
+            _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+          }
+        }
+      });
+    });
+    _vitest.describe.skip("Action Timeout", () => {
+      _vitest.test.call(void 0, "should handle action timeouts with custom duration", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        const timeoutPromise = handle.timeoutAction();
+        try {
+          await timeoutPromise;
+          _vitest.expect.call(void 0, true).toBe(false);
+        } catch (error) {
+          _vitest.expect.call(void 0, error.message).toMatch(/timed out/i);
+        }
+      });
+      _vitest.test.call(void 0, "should successfully run actions within timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        const result = await handle.delayedAction(200);
+        _vitest.expect.call(void 0, result).toBe("Completed after 200ms");
+      });
+      _vitest.test.call(void 0, "should respect different timeouts for different actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        try {
+          await client.customTimeoutActor.getOrCreate().slowAction();
+          _vitest.expect.call(void 0, true).toBe(false);
+        } catch (error) {
+          _vitest.expect.call(void 0, error.message).toMatch(/timed out/i);
+        }
+        const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
+        _vitest.expect.call(void 0, quickResult).toBe("Quick action completed");
+      });
+    });
+    _vitest.describe.call(void 0, "Error Recovery", () => {
+      _vitest.test.call(void 0, "should continue working after errors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwSimpleError();
+        } catch (error) {
+        }
+        const result = await handle.successfulAction();
+        _vitest.expect.call(void 0, result).toBe("success");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-handle.ts
+
+function runActorHandleTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Handle Tests", () => {
+    _vitest.describe.call(void 0, "Access Methods", () => {
+      _vitest.test.call(void 0, "should use .get() to access a actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        await client.counter.create(["test-get-handle"]);
+        const handle = client.counter.get(["test-get-handle"]);
+        const count = await handle.increment(5);
+        _vitest.expect.call(void 0, count).toBe(5);
+        const retrievedCount = await handle.getCount();
+        _vitest.expect.call(void 0, retrievedCount).toBe(5);
+      });
+      _vitest.test.call(void 0, "should use .getForId() to access a actor by ID", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-get-for-id-handle"]);
+        await handle.increment(3);
+        const actorId = await handle.resolve();
+        const idHandle = client.counter.getForId(actorId);
+        const count = await idHandle.getCount();
+        _vitest.expect.call(void 0, count).toBe(3);
+        const newCount = await idHandle.increment(4);
+        _vitest.expect.call(void 0, newCount).toBe(7);
+      });
+      _vitest.test.call(void 0, "should use .getOrCreate() to access or create a actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate([
+          "test-get-or-create-handle"
+        ]);
+        const count = await handle.increment(7);
+        _vitest.expect.call(void 0, count).toBe(7);
+        const sameHandle = client.counter.getOrCreate([
+          "test-get-or-create-handle"
+        ]);
+        const retrievedCount = await sameHandle.getCount();
+        _vitest.expect.call(void 0, retrievedCount).toBe(7);
+      });
+      _vitest.test.call(void 0, "should use (await create()) to create and return a handle", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-create-handle"]);
+        const count = await handle.increment(9);
+        _vitest.expect.call(void 0, count).toBe(9);
+        const retrievedCount = await handle.getCount();
+        _vitest.expect.call(void 0, retrievedCount).toBe(9);
+      });
+      _vitest.test.call(void 0, "errors when calling create twice with the same key", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const key = ["duplicate-create-handle", crypto.randomUUID()];
+        await client.counter.create(key);
+        try {
+          await client.counter.create(key);
+          _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.test.call(void 0, ".get().resolve() errors for non-existent actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const missingId = `nonexistent-${crypto.randomUUID()}`;
+        try {
+          await client.counter.get([missingId]).resolve();
+          _vitest.expect.fail("did not error for get().resolve() on missing actor");
+        } catch (err) {
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
+        }
+      });
+    });
+    _vitest.describe.call(void 0, "Action Functionality", () => {
+      _vitest.test.call(void 0, "should call actions directly on the handle", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-action-handle"]);
+        const count1 = await handle.increment(3);
+        _vitest.expect.call(void 0, count1).toBe(3);
+        const count2 = await handle.increment(5);
+        _vitest.expect.call(void 0, count2).toBe(8);
+        const retrievedCount = await handle.getCount();
+        _vitest.expect.call(void 0, retrievedCount).toBe(8);
+      });
+      _vitest.test.call(void 0, "should handle independent handles to the same actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle1 = client.counter.getOrCreate(["test-multiple-handles"]);
+        const handle2 = client.counter.get(["test-multiple-handles"]);
+        await handle1.increment(3);
+        const count = await handle2.getCount();
+        _vitest.expect.call(void 0, count).toBe(3);
+        const finalCount = await handle2.increment(4);
+        _vitest.expect.call(void 0, finalCount).toBe(7);
+        const checkCount = await handle1.getCount();
+        _vitest.expect.call(void 0, checkCount).toBe(7);
+      });
+      _vitest.test.call(void 0, "should resolve a actor's ID", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counter.getOrCreate(["test-resolve-id"]);
+        await handle.increment(1);
+        const actorId = await handle.resolve();
+        _vitest.expect.call(void 0, typeof actorId).toBe("string");
+        _vitest.expect.call(void 0, actorId).not.toBe("");
+        const idHandle = client.counter.getForId(actorId);
+        const count = await idHandle.getCount();
+        _vitest.expect.call(void 0, count).toBe(1);
+      });
+    });
+    _vitest.describe.call(void 0, "Lifecycle Hooks", () => {
+      _vitest.test.call(void 0, "should trigger lifecycle hooks on actor creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.counterWithLifecycle.getOrCreate([
+          "test-lifecycle-handle"
+        ]);
+        const initialEvents = await handle.getEvents();
+        _vitest.expect.call(void 0, initialEvents).toContain("onStart");
+        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.test.call(void 0, "should trigger lifecycle hooks for each Action call", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const viewHandle = client.counterWithLifecycle.getOrCreate([
+          "test-lifecycle-action"
+        ]);
+        const initialEvents = await viewHandle.getEvents();
+        _vitest.expect.call(void 0, initialEvents).toContain("onStart");
+        _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");
+        const trackingHandle = client.counterWithLifecycle.getOrCreate(
+          ["test-lifecycle-action"],
+          { params: { trackLifecycle: true } }
+        );
+        await trackingHandle.increment(5);
+        const eventsAfterAction = await viewHandle.getEvents();
+        _vitest.expect.call(void 0, eventsAfterAction).toContain("onBeforeConnect");
+        _vitest.expect.call(void 0, eventsAfterAction).toContain("onConnect");
+        _vitest.expect.call(void 0, eventsAfterAction).toContain("onDisconnect");
+        _vitest.expect.call(void 0, 
+          eventsAfterAction.filter((e) => e === "onBeforeConnect").length
+        ).toBe(1);
+        _vitest.expect.call(void 0, eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
+          1
+        );
+        _vitest.expect.call(void 0, 
+          eventsAfterAction.filter((e) => e === "onDisconnect").length
+        ).toBe(1);
+        await trackingHandle.increment(10);
+        const eventsAfterSecondAction = await viewHandle.getEvents();
+        _vitest.expect.call(void 0, 
+          eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length
+        ).toBe(2);
+        _vitest.expect.call(void 0, 
+          eventsAfterSecondAction.filter((e) => e === "onConnect").length
+        ).toBe(2);
+        _vitest.expect.call(void 0, 
+          eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
+        ).toBe(2);
+      });
+      _vitest.test.call(void 0, "should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const viewHandle = client.counterWithLifecycle.getOrCreate([
+          "test-lifecycle-multi-handle"
+        ]);
+        const trackingHandle1 = client.counterWithLifecycle.getOrCreate(
+          ["test-lifecycle-multi-handle"],
+          { params: { trackLifecycle: true } }
+        );
+        const trackingHandle2 = client.counterWithLifecycle.getOrCreate(
+          ["test-lifecycle-multi-handle"],
+          { params: { trackLifecycle: true } }
+        );
+        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 === "onBeforeConnect").length).toBe(2);
+        _vitest.expect.call(void 0, events.filter((e) => e === "onConnect").length).toBe(2);
+        _vitest.expect.call(void 0, events.filter((e) => e === "onDisconnect").length).toBe(2);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-inline-client.ts
+
+function runActorInlineClientTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Inline Client Tests", () => {
+    _vitest.describe.call(void 0, "Stateless Client Calls", () => {
+      _vitest.test.call(void 0, "should make stateless calls to other actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate([
+          "inline-client-test"
+        ]);
+        const result = await inlineClientHandle.callCounterIncrement(5);
+        _vitest.expect.call(void 0, result).toBe(5);
+        const counterState = await inlineClientHandle.getCounterState();
+        _vitest.expect.call(void 0, counterState).toBe(5);
+        const messages = await inlineClientHandle.getMessages();
+        _vitest.expect.call(void 0, messages).toHaveLength(2);
+        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(5), result: 5");
+        _vitest.expect.call(void 0, messages[1]).toContain("Got counter state: 5");
+      });
+      _vitest.test.call(void 0, "should handle multiple stateless calls", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate([
+          "inline-client-multi"
+        ]);
+        await inlineClientHandle.clearMessages();
+        const result1 = await inlineClientHandle.callCounterIncrement(3);
+        const result2 = await inlineClientHandle.callCounterIncrement(7);
+        const finalState = await inlineClientHandle.getCounterState();
+        _vitest.expect.call(void 0, result1).toBe(3);
+        _vitest.expect.call(void 0, result2).toBe(10);
+        _vitest.expect.call(void 0, finalState).toBe(10);
+        const messages = await inlineClientHandle.getMessages();
+        _vitest.expect.call(void 0, messages).toHaveLength(3);
+        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(3), result: 3");
+        _vitest.expect.call(void 0, messages[1]).toContain(
+          "Called counter.increment(7), result: 10"
+        );
+        _vitest.expect.call(void 0, messages[2]).toContain("Got counter state: 10");
+      });
+    });
+    _vitest.describe.call(void 0, "Stateful Client Calls", () => {
+      _vitest.test.call(void 0, "should connect to other actors and receive events", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate([
+          "inline-client-stateful"
+        ]);
+        await inlineClientHandle.clearMessages();
+        const result = await inlineClientHandle.connectToCounterAndIncrement(4);
+        _vitest.expect.call(void 0, result.result1).toBe(4);
+        _vitest.expect.call(void 0, result.result2).toBe(12);
+        _vitest.expect.call(void 0, result.events).toEqual([4, 12]);
+        const messages = await inlineClientHandle.getMessages();
+        _vitest.expect.call(void 0, messages).toHaveLength(1);
+        _vitest.expect.call(void 0, messages[0]).toContain(
+          "Connected to counter, incremented by 4 and 8"
+        );
+        _vitest.expect.call(void 0, messages[0]).toContain("results: 4, 12");
+        _vitest.expect.call(void 0, messages[0]).toContain("events: [4,12]");
+      });
+      _vitest.test.call(void 0, "should handle stateful connection independently", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate([
+          "inline-client-independent"
+        ]);
+        await inlineClientHandle.clearMessages();
+        const result = await inlineClientHandle.connectToCounterAndIncrement(2);
+        _vitest.expect.call(void 0, result.result1).toBe(2);
+        _vitest.expect.call(void 0, result.result2).toBe(6);
+        _vitest.expect.call(void 0, result.events).toEqual([2, 6]);
+        const messages = await inlineClientHandle.getMessages();
+        _vitest.expect.call(void 0, messages).toHaveLength(1);
+        _vitest.expect.call(void 0, messages[0]).toContain(
+          "Connected to counter, incremented by 2 and 4"
+        );
+      });
+    });
+    _vitest.describe.call(void 0, "Mixed Client Usage", () => {
+      _vitest.test.call(void 0, "should handle both stateless and stateful calls", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const inlineClientHandle = client.inlineClientActor.getOrCreate([
+          "inline-client-mixed"
+        ]);
+        await inlineClientHandle.clearMessages();
+        await inlineClientHandle.callCounterIncrement(1);
+        const statelessResult = await inlineClientHandle.getCounterState();
+        _vitest.expect.call(void 0, statelessResult).toBe(1);
+        const statefulResult = await inlineClientHandle.connectToCounterAndIncrement(3);
+        _vitest.expect.call(void 0, statefulResult.result1).toBe(3);
+        _vitest.expect.call(void 0, statefulResult.result2).toBe(9);
+        const messages = await inlineClientHandle.getMessages();
+        _vitest.expect.call(void 0, messages).toHaveLength(3);
+        _vitest.expect.call(void 0, messages[0]).toContain("Called counter.increment(1), result: 1");
+        _vitest.expect.call(void 0, messages[1]).toContain("Got counter state: 1");
+        _vitest.expect.call(void 0, messages[2]).toContain(
+          "Connected to counter, incremented by 3 and 6"
+        );
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-inspector.ts
+
+function runActorInspectorTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Inspector Tests", () => {
+    _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 = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.ping.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({ message: "pong" });
+      });
+      _vitest.test.call(void 0, "should get actors with pagination", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        await client.counter.create(["test-actor-1"]);
+        await client.counter.create(["test-actor-2"]);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "1" }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({ key: ["test-actor-1"] })
+          ])
+        );
+        _vitest.expect.call(void 0, data.length).toBe(1);
+      });
+      _vitest.test.call(void 0, "should get all actors with pagination", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const actorKey1 = ["test-cursor-1"];
+        const actorKey2 = ["test-cursor-2"];
+        await client.counter.create(actorKey1);
+        await client.counter.create(actorKey2);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "5" }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({
+              id: _vitest.expect.any(String),
+              key: actorKey1
+            }),
+            _vitest.expect.objectContaining({
+              id: _vitest.expect.any(String),
+              key: actorKey2
+            })
+          ])
+        );
+      });
+      _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "0" }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(400);
+      });
+      _vitest.test.call(void 0, "should create a new actor", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$post({
+          json: {
+            name: "default",
+            key: ["test-create-actor"],
+            input: {}
+          }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(201);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual(
+          _vitest.expect.objectContaining({
+            id: _vitest.expect.any(String),
+            name: "default",
+            key: ["test-create-actor"]
+          })
+        );
+      });
+      _vitest.test.call(void 0, "should get builds", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.builds.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({ name: _vitest.expect.any(String) })
+          ])
+        );
+      });
+      _vitest.test.call(void 0, "should get actor by id", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-get-by-id"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actor[":id"].$get({
+          param: { id: actorId }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toHaveProperty("id", actorId);
+      });
+      _vitest.test.call(void 0, "should return 404 for non-existent actor", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actor[":id"].$get({
+          param: { id: "non-existent-id" }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(404);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({ error: "Actor not found" });
+      });
+      _vitest.test.call(void 0, "should get bootstrap data", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-bootstrap"]);
+        await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.bootstrap.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data.actors).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({
+              key: ["test-bootstrap"],
+              name: "counter"
+            })
+          ])
+        );
+      });
+    });
+    _vitest.describe.call(void 0, "Actor Inspector", () => {
+      _vitest.test.call(void 0, "should handle actor not found", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const actorId = "non-existing";
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.ping.$get();
+        _vitest.expect.call(void 0, response.ok).toBe(false);
+      });
+      _vitest.test.call(void 0, "should respond to ping", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-ping"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.ping.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({ message: "pong" });
+      });
+      _vitest.test.call(void 0, "should get actor state", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-state"]);
+        const actorId = await handle.resolve();
+        await handle.increment(5);
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({
+          enabled: true,
+          state: _vitest.expect.objectContaining({
+            count: 5
+          })
+        });
+      });
+      _vitest.test.call(void 0, "should update actor state with replace", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-state-replace"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$patch({
+          json: {
+            replace: { count: 10 }
+          }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({
+          enabled: true,
+          state: { count: 10 }
+        });
+      });
+      _vitest.test.call(void 0, "should update actor state with patch", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-state-patch"]);
+        const actorId = await handle.resolve();
+        await handle.increment(3);
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$patch({
+          json: {
+            patch: [
+              {
+                op: "replace",
+                path: "/count",
+                value: 7
+              }
+            ]
+          }
+        });
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual({
+          enabled: true,
+          state: _vitest.expect.objectContaining({
+            count: 7
+          })
+        });
+      });
+      _vitest.test.call(void 0, "should get actor connections", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-connections"]);
+        const actorId = await handle.resolve();
+        handle.connect();
+        await handle.increment(10);
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.connections.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data.connections).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({
+              id: _vitest.expect.any(String)
+            })
+          ])
+        );
+      });
+      _vitest.test.call(void 0, "should get actor events", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-events"]);
+        const actorId = await handle.resolve();
+        handle.connect();
+        await handle.increment(10);
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.events.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data.events).toEqual(
+          _vitest.expect.arrayContaining([
+            _vitest.expect.objectContaining({
+              type: "broadcast",
+              id: _vitest.expect.any(String)
+            })
+          ])
+        );
+      });
+      _vitest.test.call(void 0, "should clear actor events", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-events-clear"]);
+        const actorId = await handle.resolve();
+        handle.connect();
+        await handle.increment(10);
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        {
+          const response2 = await http.events.$get();
+          _vitest.expect.call(void 0, response2.status).toBe(200);
+          const data = await response2.json();
+          _vitest.expect.call(void 0, data.events).toEqual(
+            _vitest.expect.arrayContaining([
+              _vitest.expect.objectContaining({
+                type: "broadcast",
+                id: _vitest.expect.any(String)
+              })
+            ])
+          );
+        }
+        const response = await http.events.clear.$post();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+      });
+      _vitest.test.call(void 0, "should get actor rpcs", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-rpcs"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.rpcs.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toEqual(
+          _vitest.expect.objectContaining({
+            rpcs: _vitest.expect.arrayContaining(["increment", "getCount"])
+          })
+        );
+      });
+      _vitest.test.skip("should get actor database info", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-db"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.db.$get();
+        _vitest.expect.call(void 0, response.status).toBe(200);
+        const data = await response.json();
+        _vitest.expect.call(void 0, data).toHaveProperty("enabled");
+        _vitest.expect.call(void 0, typeof data.enabled).toBe("boolean");
+        if (data.enabled) {
+          _vitest.expect.call(void 0, data).toHaveProperty("db");
+          _vitest.expect.call(void 0, Array.isArray(data.db)).toBe(true);
+        } else {
+          _vitest.expect.call(void 0, data.db).toBe(null);
+        }
+      });
+      _vitest.test.skip("should execute database query when database is enabled", async (c) => {
+        const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+        const handle = await client.counter.create(["test-db-query"]);
+        const actorId = await handle.resolve();
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const dbInfoResponse = await http.db.$get();
+        const dbInfo = await dbInfoResponse.json();
+        if (dbInfo.enabled) {
+          const queryResponse = await http.db.$post({
+            json: {
+              query: "SELECT 1 as test",
+              params: []
+            }
+          });
+          _vitest.expect.call(void 0, queryResponse.status).toBe(200);
+          const queryData = await queryResponse.json();
+          _vitest.expect.call(void 0, queryData).toHaveProperty("result");
+        } else {
+          const queryResponse = await http.db.$post({
+            json: {
+              query: "SELECT 1 as test",
+              params: []
+            }
+          });
+          _vitest.expect.call(void 0, queryResponse.status).toBe(200);
+          const queryData = await queryResponse.json();
+          _vitest.expect.call(void 0, queryData).toEqual({ enabled: false });
+        }
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-metadata.ts
+
+function runActorMetadataTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Metadata Tests", () => {
+    _vitest.describe.call(void 0, "Actor Name", () => {
+      _vitest.test.call(void 0, "should provide access to actor name", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const actorName = await handle.getActorName();
+        _vitest.expect.call(void 0, actorName).toBe("metadataActor");
+      });
+      _vitest.test.call(void 0, "should preserve actor name in state during onStart", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const storedName = await handle.getStoredActorName();
+        _vitest.expect.call(void 0, storedName).toBe("metadataActor");
+      });
+    });
+    _vitest.describe.call(void 0, "Actor Tags", () => {
+      _vitest.test.call(void 0, "should provide access to tags", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        await handle.setupTestTags({
+          env: "test",
+          purpose: "metadata-test"
+        });
+        const tags = await handle.getTags();
+        _vitest.expect.call(void 0, tags).toHaveProperty("env");
+        _vitest.expect.call(void 0, tags.env).toBe("test");
+        _vitest.expect.call(void 0, tags).toHaveProperty("purpose");
+        _vitest.expect.call(void 0, tags.purpose).toBe("metadata-test");
+      });
+      _vitest.test.call(void 0, "should allow accessing individual tags", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        await handle.setupTestTags({
+          category: "test-actor",
+          version: "1.0"
+        });
+        const category = await handle.getTag("category");
+        const version = await handle.getTag("version");
+        const nonexistent = await handle.getTag("nonexistent");
+        _vitest.expect.call(void 0, category).toBe("test-actor");
+        _vitest.expect.call(void 0, version).toBe("1.0");
+        _vitest.expect.call(void 0, nonexistent).toBeNull();
+      });
+    });
+    _vitest.describe.call(void 0, "Metadata Structure", () => {
+      _vitest.test.call(void 0, "should provide complete metadata object", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        await handle.setupTestTags({ type: "metadata-test" });
+        await handle.setupTestRegion("us-west-1");
+        const metadata = await handle.getMetadata();
+        _vitest.expect.call(void 0, metadata).toHaveProperty("name");
+        _vitest.expect.call(void 0, metadata.name).toBe("metadataActor");
+        _vitest.expect.call(void 0, metadata).toHaveProperty("tags");
+        _vitest.expect.call(void 0, metadata.tags).toHaveProperty("type");
+        _vitest.expect.call(void 0, metadata.tags.type).toBe("metadata-test");
+        _vitest.expect.call(void 0, metadata).toHaveProperty("region");
+        _vitest.expect.call(void 0, metadata.region).toBe("us-west-1");
+      });
+    });
+    _vitest.describe.call(void 0, "Region Information", () => {
+      _vitest.test.call(void 0, "should retrieve region information", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        await handle.setupTestRegion("eu-central-1");
+        const region = await handle.getRegion();
+        _vitest.expect.call(void 0, region).toBe("eu-central-1");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-onstatechange.ts
+
+function runActorOnStateChangeTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor onStateChange Tests", () => {
+    _vitest.test.call(void 0, "triggers onStateChange when state is modified", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.onStateChangeActor.getOrCreate();
+      await actor2.setValue(10);
+      const changeCount = await actor2.getChangeCount();
+      _vitest.expect.call(void 0, changeCount).toBe(1);
+    });
+    _vitest.test.call(void 0, "triggers onChange multiple times for multiple state changes", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.onStateChangeActor.getOrCreate();
+      await actor2.incrementMultiple(3);
+      const changeCount = await actor2.getChangeCount();
+      _vitest.expect.call(void 0, changeCount).toBe(3);
+    });
+    _vitest.test.call(void 0, "does NOT trigger onChange for read-only actions", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.onStateChangeActor.getOrCreate();
+      await actor2.setValue(5);
+      const value = await actor2.getValue();
+      _vitest.expect.call(void 0, value).toBe(5);
+      const changeCount = await actor2.getChangeCount();
+      _vitest.expect.call(void 0, changeCount).toBe(1);
+    });
+    _vitest.test.call(void 0, "does NOT trigger onChange for computed values", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.onStateChangeActor.getOrCreate();
+      await actor2.setValue(3);
+      {
+        const changeCount = await actor2.getChangeCount();
+        _vitest.expect.call(void 0, changeCount).toBe(1);
+      }
+      const doubled = await actor2.getDoubled();
+      _vitest.expect.call(void 0, doubled).toBe(6);
+      {
+        const changeCount = await actor2.getChangeCount();
+        _vitest.expect.call(void 0, changeCount).toBe(1);
+      }
+    });
+    _vitest.test.call(void 0, "simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.onStateChangeActor.getOrCreate();
+      const connection = await actor2.connect();
+      const value = await connection.getValue();
+      _vitest.expect.call(void 0, value).toBe(0);
+      await connection.dispose();
+      const changeCount = await actor2.getChangeCount();
+      _vitest.expect.call(void 0, changeCount).toBe(0);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-vars.ts
+
+function runActorVarsTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Actor Variables", () => {
+    _vitest.describe.call(void 0, "Static vars", () => {
+      _vitest.test.call(void 0, "should provide access to static vars", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.staticVarActor.getOrCreate();
+        const result = await instance.getVars();
+        _vitest.expect.call(void 0, result).toEqual({ counter: 42, name: "test-actor" });
+        const name = await instance.getName();
+        _vitest.expect.call(void 0, name).toBe("test-actor");
+      });
+    });
+    _vitest.describe.call(void 0, "Deep cloning of static vars", () => {
+      _vitest.test.call(void 0, "should deep clone static vars between actor instances", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance1 = client.nestedVarActor.getOrCreate(["instance1"]);
+        const instance2 = client.nestedVarActor.getOrCreate(["instance2"]);
+        const modifiedVars = await instance1.modifyNested();
+        _vitest.expect.call(void 0, modifiedVars.nested.value).toBe("modified");
+        _vitest.expect.call(void 0, modifiedVars.nested.array).toContain(4);
+        _vitest.expect.call(void 0, modifiedVars.nested.obj.key).toBe("new-value");
+        const instance2Vars = await instance2.getVars();
+        _vitest.expect.call(void 0, instance2Vars.nested.value).toBe("original");
+        _vitest.expect.call(void 0, instance2Vars.nested.array).toEqual([1, 2, 3]);
+        _vitest.expect.call(void 0, instance2Vars.nested.obj.key).toBe("value");
+      });
+    });
+    _vitest.describe.call(void 0, "createVars", () => {
+      _vitest.test.call(void 0, "should support dynamic vars creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.dynamicVarActor.getOrCreate();
+        const vars = await instance.getVars();
+        _vitest.expect.call(void 0, vars).toHaveProperty("random");
+        _vitest.expect.call(void 0, vars).toHaveProperty("computed");
+        _vitest.expect.call(void 0, typeof vars.random).toBe("number");
+        _vitest.expect.call(void 0, typeof vars.computed).toBe("string");
+        _vitest.expect.call(void 0, vars.computed).toMatch(/^Actor-\d+$/);
+      });
+      _vitest.test.call(void 0, "should create different vars for different instances", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance1 = client.uniqueVarActor.getOrCreate(["test1"]);
+        const instance2 = client.uniqueVarActor.getOrCreate(["test2"]);
+        const vars1 = await instance1.getVars();
+        const vars2 = await instance2.getVars();
+        _vitest.expect.call(void 0, vars1.id).not.toBe(vars2.id);
+      });
+    });
+    _vitest.describe.call(void 0, "Driver Context", () => {
+      _vitest.test.call(void 0, "should provide access to driver context", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.driverCtxActor.getOrCreate();
+        const vars = await instance.getVars();
+        _vitest.expect.call(void 0, vars).toHaveProperty("hasDriverCtx");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/manager-driver.ts
+
+function runManagerDriverTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Manager Driver Tests", () => {
+    _vitest.describe.call(void 0, "Client Connection Methods", () => {
+      _vitest.test.call(void 0, "connect() - finds or creates a actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counterA = client.counter.getOrCreate();
+        await counterA.increment(5);
+        const counterAAgain = client.counter.getOrCreate();
+        const count = await counterAAgain.increment(0);
+        _vitest.expect.call(void 0, count).toBe(5);
+        const counterB = client.counter.getOrCreate(["counter-b", "testing"]);
+        await counterB.increment(10);
+        const countB = await counterB.increment(0);
+        _vitest.expect.call(void 0, countB).toBe(10);
+      });
+      _vitest.test.call(void 0, "throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const uniqueKey = ["duplicate-actor-test", crypto.randomUUID()];
+        const counter = client.counter.getOrCreate(uniqueKey);
+        await counter.increment(5);
+        try {
+          await client.counter.create(uniqueKey);
+          _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");
+        }
+        const count = await counter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(5);
+      });
+    });
+    _vitest.describe.call(void 0, "Connection Options", () => {
+      _vitest.test.call(void 0, "get without create prevents actor creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const nonexistentId = `nonexistent-${crypto.randomUUID()}`;
+        try {
+          await client.counter.get([nonexistentId]).resolve();
+          _vitest.expect.fail("did not error for get");
+        } catch (err) {
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
+        }
+        const createdCounter = client.counter.getOrCreate(nonexistentId);
+        await createdCounter.increment(3);
+        const retrievedCounter = client.counter.get(nonexistentId);
+        const count = await retrievedCounter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(3);
+      });
+      _vitest.test.call(void 0, "connection params are passed to actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counter = client.counter.getOrCreate(void 0, {
+          params: {
+            userId: "user-123",
+            authToken: "token-abc",
+            settings: { increment: 5 }
+          }
+        });
+        await counter.increment(1);
+        const count = await counter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(1);
+      });
+    });
+    _vitest.describe.call(void 0, "Actor Creation & Retrieval", () => {
+      _vitest.test.call(void 0, "creates and retrieves actors by ID", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const uniqueId = `test-counter-${crypto.randomUUID()}`;
+        const counter = client.counter.getOrCreate([uniqueId]);
+        await counter.increment(10);
+        const retrievedCounter = client.counter.getOrCreate([uniqueId]);
+        const count = await retrievedCounter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(10);
+      });
+      _vitest.test.call(void 0, "passes input to actor during creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const testInput = {
+          name: "test-actor",
+          value: 42,
+          nested: { foo: "bar" }
+        };
+        const actor2 = await client.inputActor.create(void 0, {
+          input: testInput
+        });
+        const inputs = await actor2.getInputs();
+        _vitest.expect.call(void 0, inputs.initialInput).toEqual(testInput);
+        _vitest.expect.call(void 0, inputs.onCreateInput).toEqual(testInput);
+      });
+      _vitest.test.call(void 0, "input is undefined when not provided", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const actor2 = await client.inputActor.create();
+        const inputs = await actor2.getInputs();
+        _vitest.expect.call(void 0, inputs.initialInput).toBeUndefined();
+        _vitest.expect.call(void 0, inputs.onCreateInput).toBeUndefined();
+      });
+      _vitest.test.call(void 0, "getOrCreate passes input to actor during creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const uniqueKey = [`input-test-${crypto.randomUUID()}`];
+        const testInput = {
+          name: "getorcreate-test",
+          value: 100,
+          nested: { baz: "qux" }
+        };
+        const actor2 = client.inputActor.getOrCreate(uniqueKey, {
+          createWithInput: testInput
+        });
+        const inputs = await actor2.getInputs();
+        _vitest.expect.call(void 0, inputs.initialInput).toEqual(testInput);
+        _vitest.expect.call(void 0, inputs.onCreateInput).toEqual(testInput);
+        const existingActor = client.inputActor.getOrCreate(uniqueKey);
+        const existingInputs = await existingActor.getInputs();
+        _vitest.expect.call(void 0, existingInputs.initialInput).toEqual(testInput);
+        _vitest.expect.call(void 0, existingInputs.onCreateInput).toEqual(testInput);
+      });
+    });
+    _vitest.describe.call(void 0, "Key Matching", () => {
+      _vitest.test.call(void 0, "matches actors only with exactly the same keys", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const originalCounter = client.counter.getOrCreate([
+          "counter-match",
+          "test",
+          "us-east"
+        ]);
+        await originalCounter.increment(10);
+        const exactMatchCounter = client.counter.getOrCreate([
+          "counter-match",
+          "test",
+          "us-east"
+        ]);
+        const exactMatchCount = await exactMatchCounter.increment(0);
+        _vitest.expect.call(void 0, exactMatchCount).toBe(10);
+        const subsetMatchCounter = client.counter.getOrCreate([
+          "counter-match",
+          "test"
+        ]);
+        const subsetMatchCount = await subsetMatchCounter.increment(0);
+        _vitest.expect.call(void 0, subsetMatchCount).toBe(0);
+        const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
+        const singleKeyCount = await singleKeyCounter.increment(0);
+        _vitest.expect.call(void 0, singleKeyCount).toBe(0);
+      });
+      _vitest.test.call(void 0, "string key matches array with single string key", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const stringKeyCounter = client.counter.getOrCreate("string-key-test");
+        await stringKeyCounter.increment(7);
+        const arrayKeyCounter = client.counter.getOrCreate(["string-key-test"]);
+        const count = await arrayKeyCounter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(7);
+      });
+      _vitest.test.call(void 0, "undefined key matches empty array key and no key", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const undefinedKeyCounter = client.counter.getOrCreate(void 0);
+        await undefinedKeyCounter.increment(12);
+        const emptyArrayKeyCounter = client.counter.getOrCreate([]);
+        const emptyArrayCount = await emptyArrayKeyCounter.increment(0);
+        _vitest.expect.call(void 0, emptyArrayCount).toBe(12);
+        const noKeyCounter = client.counter.getOrCreate();
+        const noKeyCount = await noKeyCounter.increment(0);
+        _vitest.expect.call(void 0, noKeyCount).toBe(12);
+      });
+      _vitest.test.call(void 0, "no keys does not match actors with keys", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const keyedCounter = client.counter.getOrCreate([
+          "counter-with-keys",
+          "special"
+        ]);
+        await keyedCounter.increment(15);
+        const noKeysCounter = client.counter.getOrCreate();
+        const count = await noKeysCounter.increment(10);
+        _vitest.expect.call(void 0, count).toBe(10);
+      });
+      _vitest.test.call(void 0, "actors with keys match actors with no keys", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const noKeysCounter = client.counter.getOrCreate();
+        await noKeysCounter.increment(25);
+        const keyedCounter = client.counter.getOrCreate([
+          "new-counter",
+          "prod"
+        ]);
+        const keyedCount = await keyedCounter.increment(0);
+        _vitest.expect.call(void 0, keyedCount).toBe(0);
+      });
+    });
+    _vitest.describe.call(void 0, "Multiple Actor Instances", () => {
+      _vitest.test.call(void 0, "creates multiple actor instances of the same type", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance1 = client.counter.getOrCreate(["multi-1"]);
+        const instance2 = client.counter.getOrCreate(["multi-2"]);
+        const instance3 = client.counter.getOrCreate(["multi-3"]);
+        await instance1.increment(1);
+        await instance2.increment(2);
+        await instance3.increment(3);
+        const retrieved1 = client.counter.getOrCreate(["multi-1"]);
+        const retrieved2 = client.counter.getOrCreate(["multi-2"]);
+        const retrieved3 = client.counter.getOrCreate(["multi-3"]);
+        _vitest.expect.call(void 0, await retrieved1.increment(0)).toBe(1);
+        _vitest.expect.call(void 0, await retrieved2.increment(0)).toBe(2);
+        _vitest.expect.call(void 0, await retrieved3.increment(0)).toBe(3);
+      });
+      _vitest.test.call(void 0, "handles default instance with no explicit ID", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const defaultCounter = client.counter.getOrCreate();
+        await defaultCounter.increment(5);
+        const sameDefaultCounter = client.counter.getOrCreate();
+        const count = await sameDefaultCounter.increment(0);
+        _vitest.expect.call(void 0, count).toBe(5);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-http.ts
+
+function runRawHttpTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "raw http", () => {
+    _vitest.test.call(void 0, "should handle raw HTTP GET requests", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["test"]);
+      const helloResponse = await actor2.fetch("api/hello");
+      _vitest.expect.call(void 0, helloResponse.ok).toBe(true);
+      const helloData = await helloResponse.json();
+      _vitest.expect.call(void 0, helloData).toEqual({ message: "Hello from actor!" });
+    });
+    _vitest.test.call(void 0, "should handle raw HTTP POST requests with echo", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["test"]);
+      const testData = { test: "data", number: 123 };
+      const echoResponse = await actor2.fetch("api/echo", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(testData)
+      });
+      _vitest.expect.call(void 0, echoResponse.ok).toBe(true);
+      const echoData = await echoResponse.json();
+      _vitest.expect.call(void 0, echoData).toEqual(testData);
+    });
+    _vitest.test.call(void 0, "should track state across raw HTTP requests", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["state-test"]);
+      await actor2.fetch("api/hello");
+      await actor2.fetch("api/hello");
+      await actor2.fetch("api/state");
+      const stateResponse = await actor2.fetch("api/state");
+      _vitest.expect.call(void 0, stateResponse.ok).toBe(true);
+      const stateData = await stateResponse.json();
+      _vitest.expect.call(void 0, stateData.requestCount).toBe(4);
+    });
+    _vitest.test.call(void 0, "should pass headers correctly", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["headers-test"]);
+      const customHeaders = {
+        "X-Custom-Header": "test-value",
+        "X-Another-Header": "another-value"
+      };
+      const response = await actor2.fetch("api/headers", {
+        headers: customHeaders
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const headers = await response.json();
+      _vitest.expect.call(void 0, headers["x-custom-header"]).toBe("test-value");
+      _vitest.expect.call(void 0, headers["x-another-header"]).toBe("another-value");
+    });
+    _vitest.test.call(void 0, "should return 404 for unhandled paths", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["404-test"]);
+      const response = await actor2.fetch("api/nonexistent");
+      _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) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpNoHandlerActor.getOrCreate(["no-handler"]);
+      const response = await actor2.fetch("api/anything");
+      _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) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpVoidReturnActor.getOrCreate(["void-return"]);
+      const response = await actor2.fetch("api/anything");
+      _vitest.expect.call(void 0, response.ok).toBe(false);
+      _vitest.expect.call(void 0, response.status).toBe(500);
+      try {
+        const errorData = await response.json();
+        _vitest.expect.call(void 0, errorData.message).toContain(
+          "onFetch handler must return a Response"
+        );
+      } catch (e3) {
+      }
+    });
+    _vitest.test.call(void 0, "should handle different HTTP methods", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["methods-test"]);
+      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+      for (const method of methods) {
+        const response = await actor2.fetch("api/echo", {
+          method,
+          body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
+        });
+        if (method === "POST") {
+          _vitest.expect.call(void 0, response.ok).toBe(true);
+          const data = await response.json();
+          _vitest.expect.call(void 0, data).toEqual({ method });
+        } else if (method === "GET") {
+          _vitest.expect.call(void 0, response.status).toBe(404);
+        } else {
+          _vitest.expect.call(void 0, response.status).toBe(404);
+        }
+      }
+    });
+    _vitest.test.call(void 0, "should handle binary data", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["binary-test"]);
+      const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+      const response = await actor2.fetch("api/echo", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/octet-stream"
+        },
+        body: binaryData
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const responseBuffer = await response.arrayBuffer();
+      const responseArray = new Uint8Array(responseBuffer);
+      _vitest.expect.call(void 0, Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+    });
+    _vitest.test.call(void 0, "should work with Hono router using createVars", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpHonoActor.getOrCreate(["hono-test"]);
+      const rootResponse = await actor2.fetch("/");
+      _vitest.expect.call(void 0, rootResponse.ok).toBe(true);
+      const rootData = await rootResponse.json();
+      _vitest.expect.call(void 0, rootData).toEqual({ message: "Welcome to Hono actor!" });
+      const usersResponse = await actor2.fetch("/users");
+      _vitest.expect.call(void 0, usersResponse.ok).toBe(true);
+      const users = await usersResponse.json();
+      _vitest.expect.call(void 0, users).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+      const userResponse = await actor2.fetch("/users/1");
+      _vitest.expect.call(void 0, userResponse.ok).toBe(true);
+      const user = await userResponse.json();
+      _vitest.expect.call(void 0, user).toEqual({ id: 1, name: "Alice" });
+      const newUser = { name: "Charlie" };
+      const createResponse = await actor2.fetch("/users", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(newUser)
+      });
+      _vitest.expect.call(void 0, createResponse.ok).toBe(true);
+      _vitest.expect.call(void 0, createResponse.status).toBe(201);
+      const createdUser = await createResponse.json();
+      _vitest.expect.call(void 0, createdUser).toEqual({ id: 3, name: "Charlie" });
+      const updateData = { name: "Alice Updated" };
+      const updateResponse = await actor2.fetch("/users/1", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(updateData)
+      });
+      _vitest.expect.call(void 0, updateResponse.ok).toBe(true);
+      const updatedUser = await updateResponse.json();
+      _vitest.expect.call(void 0, updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      const deleteResponse = await actor2.fetch("/users/2", {
+        method: "DELETE"
+      });
+      _vitest.expect.call(void 0, deleteResponse.ok).toBe(true);
+      const deleteResult = await deleteResponse.json();
+      _vitest.expect.call(void 0, deleteResult).toEqual({ message: "User 2 deleted" });
+      const notFoundResponse = await actor2.fetch("/api/unknown");
+      _vitest.expect.call(void 0, notFoundResponse.ok).toBe(false);
+      _vitest.expect.call(void 0, notFoundResponse.status).toBe(404);
+    });
+    _vitest.test.call(void 0, "should handle paths with and without leading slashes", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["path-test"]);
+      const responseWithoutSlash = await actor2.fetch("api/hello");
+      _vitest.expect.call(void 0, responseWithoutSlash.ok).toBe(true);
+      const dataWithoutSlash = await responseWithoutSlash.json();
+      _vitest.expect.call(void 0, dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      const responseWithSlash = await actor2.fetch("/api/hello");
+      _vitest.expect.call(void 0, responseWithSlash.ok).toBe(true);
+      const dataWithSlash = await responseWithSlash.json();
+      _vitest.expect.call(void 0, dataWithSlash).toEqual({ message: "Hello from actor!" });
+    });
+    _vitest.test.call(void 0, "should not create double slashes in request URLs", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpHonoActor.getOrCreate(["url-test"]);
+      const response = await actor2.fetch("/users");
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+    });
+    _vitest.test.call(void 0, "should handle forwarded requests correctly without double slashes", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-test"]);
+      const truncatedPath = "/users";
+      const url = new URL(truncatedPath, "http://example.com");
+      const newRequest = new Request(url, {
+        method: "GET"
+      });
+      const response = await actor2.fetch(truncatedPath, newRequest);
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const users = await response.json();
+      _vitest.expect.call(void 0, users).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+    });
+    _vitest.test.call(void 0, "example fix: should properly forward requests using just Request object", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpHonoActor.getOrCreate(["forward-fix"]);
+      const truncatedPath = "/users/1";
+      const url = new URL(truncatedPath, "http://example.com");
+      const newRequest = new Request(url, {
+        method: "GET"
+      });
+      const response = await actor2.fetch(newRequest);
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const user = await response.json();
+      _vitest.expect.call(void 0, user).toEqual({ id: 1, name: "Alice" });
+    });
+    _vitest.test.call(void 0, "should support standard fetch API with URL and Request objects", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpActor.getOrCreate(["fetch-api-test"]);
+      const url = new URL("/api/echo", "http://example.com");
+      const urlResponse = await actor2.fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ from: "URL object" })
+      });
+      _vitest.expect.call(void 0, urlResponse.ok).toBe(true);
+      const urlData = await urlResponse.json();
+      _vitest.expect.call(void 0, urlData).toEqual({ from: "URL object" });
+      const request = new Request("http://example.com/api/echo", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ from: "Request object" })
+      });
+      const requestResponse = await actor2.fetch(request);
+      _vitest.expect.call(void 0, requestResponse.ok).toBe(true);
+      const requestData = await requestResponse.json();
+      _vitest.expect.call(void 0, requestData).toEqual({ from: "Request object" });
+      const request2 = new Request("http://example.com/api/headers", {
+        method: "GET",
+        headers: { "X-Original": "request-header" }
+      });
+      const overrideResponse = await actor2.fetch(request2, {
+        headers: { "X-Override": "init-header" }
+      });
+      _vitest.expect.call(void 0, overrideResponse.ok).toBe(true);
+      const headers = await overrideResponse.json();
+      _vitest.expect.call(void 0, headers["x-override"]).toBe("init-header");
+      _vitest.expect.call(void 0, headers["x-original"]).toBe("request-header");
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-http-request-properties.ts
+
+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) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/path?foo=bar&baz=qux", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Custom-Header": "custom-value",
+          Authorization: "Bearer test-token"
+        },
+        body: JSON.stringify({ test: "data" })
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.url).toContain("/test/path?foo=bar&baz=qux");
+      _vitest.expect.call(void 0, data.pathname).toBe("/test/path");
+      _vitest.expect.call(void 0, data.search).toBe("?foo=bar&baz=qux");
+      _vitest.expect.call(void 0, data.searchParams).toEqual({
+        foo: "bar",
+        baz: "qux"
+      });
+      _vitest.expect.call(void 0, data.method).toBe("POST");
+      _vitest.expect.call(void 0, data.headers["content-type"]).toBe("application/json");
+      _vitest.expect.call(void 0, data.headers["x-custom-header"]).toBe("custom-value");
+      _vitest.expect.call(void 0, data.headers["authorization"]).toBe("Bearer test-token");
+      _vitest.expect.call(void 0, data.body).toEqual({ test: "data" });
+    });
+    _vitest.test.call(void 0, "should handle GET requests with no body", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/get", {
+        method: "GET"
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.method).toBe("GET");
+      _vitest.expect.call(void 0, data.body).toBeNull();
+    });
+    _vitest.test.call(void 0, "should handle different content types", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const formData = new URLSearchParams();
+      formData.append("field1", "value1");
+      formData.append("field2", "value2");
+      const formResponse = await actor2.fetch("test/form", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: formData.toString()
+      });
+      _vitest.expect.call(void 0, formResponse.ok).toBe(true);
+      const formResult = await formResponse.json();
+      _vitest.expect.call(void 0, formResult.headers["content-type"]).toBe(
+        "application/x-www-form-urlencoded"
+      );
+      _vitest.expect.call(void 0, formResult.bodyText).toBe("field1=value1&field2=value2");
+      const textResponse = await actor2.fetch("test/text", {
+        method: "POST",
+        headers: {
+          "Content-Type": "text/plain"
+        },
+        body: "Hello, World!"
+      });
+      _vitest.expect.call(void 0, textResponse.ok).toBe(true);
+      const textResult = await textResponse.json();
+      _vitest.expect.call(void 0, textResult.headers["content-type"]).toBe("text/plain");
+      _vitest.expect.call(void 0, textResult.bodyText).toBe("Hello, World!");
+    });
+    _vitest.test.call(void 0, "should preserve all header casing and values", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/headers", {
+        headers: {
+          Accept: "application/json",
+          "Accept-Language": "en-US,en;q=0.9",
+          "Cache-Control": "no-cache",
+          "User-Agent": "RivetKit-Test/1.0",
+          "X-Request-ID": "12345"
+        }
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.headers["accept"]).toBe("application/json");
+      _vitest.expect.call(void 0, data.headers["accept-language"]).toBe("en-US,en;q=0.9");
+      _vitest.expect.call(void 0, data.headers["cache-control"]).toBe("no-cache");
+      _vitest.expect.call(void 0, data.headers["user-agent"]).toBeTruthy();
+      _vitest.expect.call(void 0, data.headers["x-request-id"]).toBe("12345");
+    });
+    _vitest.test.call(void 0, "should handle empty and special URL paths", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const rootResponse = await actor2.fetch("");
+      _vitest.expect.call(void 0, rootResponse.ok).toBe(true);
+      const rootData = await rootResponse.json();
+      _vitest.expect.call(void 0, rootData.pathname).toBe("/");
+      const specialResponse = await actor2.fetch(
+        "test/path%20with%20spaces/and%2Fslashes"
+      );
+      _vitest.expect.call(void 0, specialResponse.ok).toBe(true);
+      const specialData = await specialResponse.json();
+      _vitest.expect.call(void 0, specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
+      const fragmentResponse = await actor2.fetch("test/path#fragment");
+      _vitest.expect.call(void 0, fragmentResponse.ok).toBe(true);
+      const fragmentData = await fragmentResponse.json();
+      _vitest.expect.call(void 0, fragmentData.pathname).toBe("/test/path");
+      _vitest.expect.call(void 0, fragmentData.hash).toBe("");
+    });
+    _vitest.test.call(void 0, "should handle request properties for all HTTP methods", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const methods = [
+        "GET",
+        "POST",
+        "PUT",
+        "DELETE",
+        "PATCH",
+        "HEAD",
+        "OPTIONS"
+      ];
+      for (const method of methods) {
+        const response = await actor2.fetch(`test/${method.toLowerCase()}`, {
+          method,
+          // Only include body for methods that support it
+          body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
+        });
+        if (method === "HEAD") {
+          _vitest.expect.call(void 0, response.status).toBe(200);
+          const text = await response.text();
+          _vitest.expect.call(void 0, text).toBe("");
+        } else if (method === "OPTIONS") {
+          _vitest.expect.call(void 0, response.status).toBe(204);
+          const text = await response.text();
+          _vitest.expect.call(void 0, text).toBe("");
+        } else {
+          _vitest.expect.call(void 0, response.ok).toBe(true);
+          const data = await response.json();
+          _vitest.expect.call(void 0, data.method).toBe(method);
+        }
+      }
+    });
+    _vitest.test.call(void 0, "should handle complex query parameters", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch(
+        "test?key=value1&key=value2&array[]=1&array[]=2&nested[prop]=val"
+      );
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.searchParams.key).toBe("value2");
+      _vitest.expect.call(void 0, data.searchParams["array[]"]).toBe("2");
+      _vitest.expect.call(void 0, data.searchParams["nested[prop]"]).toBe("val");
+    });
+    _vitest.test.call(void 0, "should handle multipart form data", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const boundary = "----RivetKitBoundary";
+      const body = [
+        `------${boundary}`,
+        'Content-Disposition: form-data; name="field1"',
+        "",
+        "value1",
+        `------${boundary}`,
+        'Content-Disposition: form-data; name="field2"',
+        "",
+        "value2",
+        `------${boundary}--`
+      ].join("\r\n");
+      const response = await actor2.fetch("test/multipart", {
+        method: "POST",
+        headers: {
+          "Content-Type": `multipart/form-data; boundary=----${boundary}`
+        },
+        body
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.headers["content-type"]).toContain("multipart/form-data");
+      _vitest.expect.call(void 0, data.bodyText).toContain("field1");
+      _vitest.expect.call(void 0, data.bodyText).toContain("value1");
+    });
+    _vitest.test.call(void 0, "should handle very long URLs", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const longValue = "x".repeat(1e3);
+      const response = await actor2.fetch(`test/long?param=${longValue}`);
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _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) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const largeArray = new Array(1e4).fill({
+        id: 1,
+        name: "Test",
+        description: "This is a test object with some data"
+      });
+      const response = await actor2.fetch("test/large", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(largeArray)
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.body).toHaveLength(1e4);
+    });
+    _vitest.test.call(void 0, "should handle missing content-type header", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/no-content-type", {
+        method: "POST",
+        body: "plain text without content-type"
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.bodyText).toBe("plain text without content-type");
+    });
+    _vitest.test.call(void 0, "should handle empty request body", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/empty", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        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);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      try {
+        const response = await actor2.fetch("test/custom", {
+          method: "CUSTOM"
+        });
+        if (response.ok) {
+          const data = await response.json();
+          _vitest.expect.call(void 0, data.method).toBe("CUSTOM");
+        }
+      } catch (error) {
+      }
+    });
+    _vitest.test.call(void 0, "should handle cookies in headers", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch("test/cookies", {
+        headers: {
+          Cookie: "session=abc123; user=test; preferences=dark_mode"
+        }
+      });
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.headers.cookie).toBe(
+        "session=abc123; user=test; preferences=dark_mode"
+      );
+    });
+    _vitest.test.call(void 0, "should handle URL encoding properly", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const response = await actor2.fetch(
+        "test/encoded?special=%20%21%40%23%24%25%5E%26&unicode=%E2%9C%93&email=test%40example.com"
+      );
+      _vitest.expect.call(void 0, response.ok).toBe(true);
+      const data = await response.json();
+      _vitest.expect.call(void 0, data.searchParams.special).toBe(" !@#$%^&");
+      _vitest.expect.call(void 0, data.searchParams.unicode).toBe("\u2713");
+      _vitest.expect.call(void 0, data.searchParams.email).toBe("test@example.com");
+    });
+    _vitest.test.call(void 0, "should handle concurrent requests maintaining separate contexts", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
+      const requests = [
+        actor2.fetch("test/concurrent?id=1", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ request: 1 })
+        }),
+        actor2.fetch("test/concurrent?id=2", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ request: 2 })
+        }),
+        actor2.fetch("test/concurrent?id=3", {
+          method: "DELETE"
+        })
+      ];
+      const responses = await Promise.all(requests);
+      const results = await Promise.all(
+        responses.map((r) => r.json())
+      );
+      _vitest.expect.call(void 0, results[0].searchParams.id).toBe("1");
+      _vitest.expect.call(void 0, results[0].method).toBe("POST");
+      _vitest.expect.call(void 0, results[0].body).toEqual({ request: 1 });
+      _vitest.expect.call(void 0, results[1].searchParams.id).toBe("2");
+      _vitest.expect.call(void 0, results[1].method).toBe("PUT");
+      _vitest.expect.call(void 0, results[1].body).toEqual({ request: 2 });
+      _vitest.expect.call(void 0, results[2].searchParams.id).toBe("3");
+      _vitest.expect.call(void 0, results[2].method).toBe("DELETE");
+      _vitest.expect.call(void 0, results[2].body).toBeNull();
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-websocket.ts
+
+function runRawWebSocketTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "raw websocket", () => {
+    _vitest.test.call(void 0, "should establish raw WebSocket connection", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
+      const ws = await actor2.websocket();
+      await new Promise((resolve2) => {
+        if (ws.readyState === WebSocket.OPEN) {
+          resolve2();
+        } else {
+          ws.addEventListener(
+            "open",
+            () => {
+              resolve2();
+            },
+            { once: true }
+          );
+        }
+      });
+      const welcomeMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
+      _vitest.expect.call(void 0, welcomeMessage.connectionCount).toBe(1);
+      ws.close();
+    });
+    _vitest.test.call(void 0, "should echo messages", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
+      const ws = await actor2.websocket();
+      if (ws.readyState !== WebSocket.OPEN) {
+        await new Promise((resolve2, reject) => {
+          ws.addEventListener("open", () => resolve2(), { once: true });
+          ws.addEventListener("close", reject);
+        });
+      }
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("message", () => resolve2(), { once: true });
+        ws.addEventListener("close", reject);
+      });
+      const testMessage = { test: "data", timestamp: Date.now() };
+      ws.send(JSON.stringify(testMessage));
+      const echoMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      _vitest.expect.call(void 0, echoMessage).toEqual(testMessage);
+      ws.close();
+    });
+    _vitest.test.call(void 0, "should handle ping/pong protocol", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
+      const ws = await actor2.websocket();
+      if (ws.readyState !== WebSocket.OPEN) {
+        await new Promise((resolve2, reject) => {
+          ws.addEventListener("open", () => resolve2(), { once: true });
+          ws.addEventListener("close", reject);
+        });
+      }
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("message", () => resolve2(), { once: true });
+        ws.addEventListener("close", reject);
+      });
+      ws.send(JSON.stringify({ type: "ping" }));
+      const pongMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener("message", (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "pong") {
+            resolve2(data);
+          }
+        });
+        ws.addEventListener("close", reject);
+      });
+      _vitest.expect.call(void 0, pongMessage.type).toBe("pong");
+      _vitest.expect.call(void 0, pongMessage.timestamp).toBeDefined();
+      ws.close();
+    });
+    _vitest.test.call(void 0, "should track stats across connections", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
+      const ws1 = await actor1.websocket();
+      const ws1MessagePromise = new Promise((resolve2, reject) => {
+        ws1.addEventListener("message", () => resolve2(), { once: true });
+        ws1.addEventListener("close", reject);
+      });
+      await ws1MessagePromise;
+      const actor2 = client.rawWebSocketActor.get(["stats"]);
+      const ws2 = await actor2.websocket();
+      const ws2MessagePromise = new Promise((resolve2, reject) => {
+        ws2.addEventListener("message", () => resolve2(), { once: true });
+        ws2.addEventListener("close", reject);
+      });
+      await Promise.all([ws1MessagePromise, ws2MessagePromise]);
+      const pingPromise = new Promise((resolve2, reject) => {
+        ws2.addEventListener("message", (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "pong") {
+            resolve2(void 0);
+          }
+        });
+        ws2.addEventListener("close", reject);
+      });
+      ws1.send(JSON.stringify({ data: "test1" }));
+      ws1.send(JSON.stringify({ data: "test3" }));
+      ws2.send(JSON.stringify({ type: "ping" }));
+      await pingPromise;
+      const statsPromise = new Promise((resolve2, reject) => {
+        ws1.addEventListener("message", (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "stats") {
+            resolve2(data);
+          }
+        });
+        ws1.addEventListener("close", reject);
+      });
+      ws1.send(JSON.stringify({ type: "getStats" }));
+      const stats = await statsPromise;
+      _vitest.expect.call(void 0, stats.connectionCount).toBe(2);
+      _vitest.expect.call(void 0, stats.messageCount).toBe(4);
+      const actionStats = await actor1.getStats();
+      _vitest.expect.call(void 0, actionStats.connectionCount).toBe(2);
+      _vitest.expect.call(void 0, actionStats.messageCount).toBe(4);
+      ws1.close();
+      ws2.close();
+    });
+    _vitest.test.call(void 0, "should handle binary data", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketBinaryActor.getOrCreate(["binary"]);
+      const ws = await actor2.websocket();
+      if (ws.readyState !== WebSocket.OPEN) {
+        await new Promise((resolve2, reject) => {
+          ws.addEventListener("open", () => resolve2(), { once: true });
+          ws.addEventListener("close", reject);
+        });
+      }
+      const receiveBinaryMessage = async () => {
+        const response = await new Promise(
+          (resolve2, reject) => {
+            ws.addEventListener(
+              "message",
+              (event) => {
+                resolve2(event.data);
+              },
+              { once: true }
+            );
+            ws.addEventListener("close", reject);
+          }
+        );
+        const buffer = response instanceof Blob ? await response.arrayBuffer() : response;
+        return new Uint8Array(buffer);
+      };
+      const smallData = new Uint8Array([1, 2, 3, 4, 5]);
+      ws.send(smallData);
+      const smallReversed = await receiveBinaryMessage();
+      _vitest.expect.call(void 0, Array.from(smallReversed)).toEqual([5, 4, 3, 2, 1]);
+      const largeData = new Uint8Array(1024);
+      for (let i = 0; i < largeData.length; i++) {
+        largeData[i] = i % 256;
+      }
+      ws.send(largeData);
+      const largeReversed = await receiveBinaryMessage();
+      for (let i = 0; i < largeData.length; i++) {
+        _vitest.expect.call(void 0, largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+      }
+      ws.close();
+    });
+    _vitest.test.call(void 0, "should work with custom paths", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["paths"]);
+      const ws = await actor2.websocket("custom/path");
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("open", () => {
+          resolve2();
+        });
+        ws.addEventListener("error", reject);
+        ws.addEventListener("close", reject);
+      });
+      const welcomeMessage = await new Promise((resolve2) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+      });
+      _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((resolve2) => {
+        ws.addEventListener("open", () => resolve2(), { once: true });
+      });
+      ws.send(JSON.stringify({ type: "getAuthData" }));
+      const response = await new Promise((resolve2, reject) => {
+        ws.addEventListener("message", (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "authData") {
+            resolve2(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"]);
+      const ws = await actor2.websocket();
+      if (ws.readyState !== WebSocket.OPEN) {
+        await new Promise((resolve2, reject) => {
+          ws.addEventListener("open", () => resolve2(), { once: true });
+          ws.addEventListener("close", reject);
+        });
+      }
+      const initialStats = await actor2.getStats();
+      _vitest.expect.call(void 0, initialStats.connectionCount).toBe(1);
+      const closePromise = new Promise((resolve2) => {
+        ws.addEventListener("close", () => resolve2(), { once: true });
+      });
+      ws.close();
+      await closePromise;
+      let finalStats;
+      for (let i = 0; i < 20; i++) {
+        finalStats = await actor2.getStats();
+        if (finalStats.connectionCount === 0) {
+          break;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
+      }
+      _vitest.expect.call(void 0, finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+    });
+    _vitest.test.call(void 0, "should properly handle onWebSocket open and close events", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["open-close-test"]);
+      const ws1 = await actor2.websocket();
+      await new Promise((resolve2, reject) => {
+        ws1.addEventListener("open", () => resolve2(), { once: true });
+        ws1.addEventListener("close", reject);
+      });
+      const welcome1 = await new Promise((resolve2, reject) => {
+        ws1.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws1.addEventListener("close", reject);
+      });
+      _vitest.expect.call(void 0, welcome1.type).toBe("welcome");
+      _vitest.expect.call(void 0, welcome1.connectionCount).toBe(1);
+      const ws2 = await actor2.websocket();
+      await new Promise((resolve2, reject) => {
+        ws2.addEventListener("open", () => resolve2(), { once: true });
+        ws2.addEventListener("close", reject);
+      });
+      const welcome2 = await new Promise((resolve2, reject) => {
+        ws2.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws2.addEventListener("close", reject);
+      });
+      _vitest.expect.call(void 0, welcome2.type).toBe("welcome");
+      _vitest.expect.call(void 0, welcome2.connectionCount).toBe(2);
+      const midStats = await actor2.getStats();
+      _vitest.expect.call(void 0, midStats.connectionCount).toBe(2);
+      ws1.close();
+      await new Promise((resolve2) => {
+        ws1.addEventListener("close", () => resolve2(), { once: true });
+      });
+      let afterFirstClose;
+      for (let i = 0; i < 20; i++) {
+        afterFirstClose = await actor2.getStats();
+        if (afterFirstClose.connectionCount === 1) {
+          break;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
+      }
+      _vitest.expect.call(void 0, afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      ws2.close();
+      await new Promise((resolve2) => {
+        ws2.addEventListener("close", () => resolve2(), { once: true });
+      });
+      let finalStats;
+      for (let i = 0; i < 20; i++) {
+        finalStats = await actor2.getStats();
+        if (finalStats.connectionCount === 0) {
+          break;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
+      }
+      _vitest.expect.call(void 0, finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+    });
+    _vitest.test.call(void 0, "should handle query parameters in websocket paths", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const actor2 = client.rawWebSocketActor.getOrCreate(["query-params"]);
+      const ws = await actor2.websocket("api/v1/stream?token=abc123&user=test");
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("open", () => resolve2(), { once: true });
+        ws.addEventListener("error", reject);
+      });
+      const requestInfoPromise = new Promise((resolve2, reject) => {
+        ws.addEventListener("message", (event) => {
+          const data = JSON.parse(event.data);
+          if (data.type === "requestInfo") {
+            resolve2(data);
+          }
+        });
+        ws.addEventListener("close", reject);
+      });
+      ws.send(JSON.stringify({ type: "getRequestInfo" }));
+      const requestInfo = await requestInfoPromise;
+      _vitest.expect.call(void 0, requestInfo.url).toContain("api/v1/stream");
+      _vitest.expect.call(void 0, requestInfo.url).toContain("token=abc123");
+      _vitest.expect.call(void 0, requestInfo.url).toContain("user=test");
+      ws.close();
+    });
+  });
+}
+
+// src/driver-test-suite/tests/request-access.ts
+
+function runRequestAccessTests(driverTestConfig) {
+  _vitest.describe.call(void 0, "Request Access in Lifecycle Hooks", () => {
+    _vitest.test.call(void 0, "should have access to request object in onBeforeConnect and createConnState", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.requestAccessActor.getOrCreate(["test-request"], {
+        params: { trackRequest: true }
+      });
+      const connection = handle.connect();
+      const requestInfo = await connection.getRequestInfo();
+      if (driverTestConfig.clientType === "http") {
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
+        _vitest.expect.call(void 0, requestInfo.createConnState.hasRequest).toBe(true);
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestUrl).toBeDefined();
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestMethod).toBeDefined();
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestHeaders).toBeDefined();
+      } else {
+      }
+      await connection.dispose();
+    });
+    _vitest.test.call(void 0, "should not have request when trackRequest is false", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.requestAccessActor.getOrCreate(
+        ["test-no-request"],
+        {
+          params: { trackRequest: false }
+        }
+      );
+      const connection = handle.connect();
+      const requestInfo = await connection.getRequestInfo();
+      _vitest.expect.call(void 0, requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      _vitest.expect.call(void 0, 
+        Object.keys(requestInfo.onBeforeConnect.requestHeaders)
+      ).toHaveLength(0);
+      _vitest.expect.call(void 0, requestInfo.createConnState.hasRequest).toBe(false);
+      _vitest.expect.call(void 0, requestInfo.createConnState.requestUrl).toBeNull();
+      _vitest.expect.call(void 0, requestInfo.createConnState.requestMethod).toBeNull();
+      _vitest.expect.call(void 0, 
+        Object.keys(requestInfo.createConnState.requestHeaders)
+      ).toHaveLength(0);
+      await connection.dispose();
+    });
+    _vitest.test.call(void 0, "should capture request headers and method", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.requestAccessActor.getOrCreate(["test-headers"], {
+        params: { trackRequest: true }
+      });
+      const connection = handle.connect();
+      const requestInfo = await connection.getRequestInfo();
+      if (driverTestConfig.clientType === "http") {
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
+        _vitest.expect.call(void 0, requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
+        _vitest.expect.call(void 0, typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+          "object"
+        );
+        _vitest.expect.call(void 0, requestInfo.createConnState.hasRequest).toBe(true);
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestMethod).toBeTruthy();
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestUrl).toBeTruthy();
+        _vitest.expect.call(void 0, requestInfo.createConnState.requestHeaders).toBeTruthy();
+        _vitest.expect.call(void 0, typeof requestInfo.createConnState.requestHeaders).toBe(
+          "object"
+        );
+      } else {
+      }
+      await connection.dispose();
+    });
+  });
+}
+
+// src/driver-test-suite/mod.ts
+function runDriverTests(driverTestConfigPartial) {
+  for (const clientType of ["http", "inline"]) {
+    const driverTestConfig = {
+      ...driverTestConfigPartial,
+      clientType
+    };
+    _vitest.describe.call(void 0, `client type (${clientType})`, () => {
+      runActorDriverTests(driverTestConfig);
+      runManagerDriverTests(driverTestConfig);
+      for (const transport of ["websocket", "sse"]) {
+        _vitest.describe.call(void 0, `transport (${transport})`, () => {
+          runActorConnTests({
+            ...driverTestConfig,
+            transport
+          });
+          runActorConnStateTests({ ...driverTestConfig, transport });
+          runRequestAccessTests({ ...driverTestConfig, transport });
+          runActorDriverTestsWithTransport({ ...driverTestConfig, transport });
+        });
+      }
+      runActorHandleTests(driverTestConfig);
+      runActionFeaturesTests(driverTestConfig);
+      runActorVarsTests(driverTestConfig);
+      runActorMetadataTests(driverTestConfig);
+      runActorOnStateChangeTests(driverTestConfig);
+      runActorErrorHandlingTests(driverTestConfig);
+      runActorInlineClientTests(driverTestConfig);
+      runRawHttpTests(driverTestConfig);
+      runRawHttpRequestPropertiesTests(driverTestConfig);
+      runRawWebSocketTests(driverTestConfig);
+      runActorInspectorTests(driverTestConfig);
+    });
+  }
+}
+async function createTestRuntime(registryPath, driverFactory) {
+  const {
+    mod: { registry }
+  } = await _bundlerequire.bundleRequire.call(void 0, {
+    filepath: registryPath
+  });
+  registry.config.test.enabled = true;
+  const {
+    driver,
+    cleanup: driverCleanup,
+    rivetEngine
+  } = await driverFactory(registry);
+  if (rivetEngine) {
+    const cleanup = async () => {
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: rivetEngine.endpoint,
+      namespace: rivetEngine.namespace,
+      runnerName: rivetEngine.runnerName,
+      cleanup
+    };
+  } else {
+    let upgradeWebSocket;
+    const config = _chunkWHBPJNGWcjs.RunConfigSchema.parse({
+      driver,
+      getUpgradeWebSocket: () => upgradeWebSocket,
+      inspector: {
+        enabled: true,
+        token: () => "token"
+      }
+    });
+    const managerDriver = driver.manager(registry.config, config);
+    const { router } = _chunkVO7ZRVVDcjs.createManagerRouter.call(void 0, 
+      registry.config,
+      config,
+      managerDriver,
+      false
+    );
+    const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
+    upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+    const port = await _chunkIH6CKNDWcjs.getPort.call(void 0, );
+    const server = _nodeserver.serve.call(void 0, {
+      fetch: router.fetch,
+      hostname: "127.0.0.1",
+      port
+    });
+    _invariant2.default.call(void 0, 
+      nodeWebSocket.injectWebSocket !== void 0,
+      "should have injectWebSocket"
+    );
+    nodeWebSocket.injectWebSocket(server);
+    const serverEndpoint = `http://127.0.0.1:${port}`;
+    logger().info({ msg: "test serer listening", port });
+    const cleanup = async () => {
+      await new Promise((resolve2) => server.close(() => resolve2(void 0)));
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: serverEndpoint,
+      namespace: "default",
+      runnerName: "rivetkit",
+      cleanup
+    };
+  }
+}
+
+
+
+exports.createTestRuntime = createTestRuntime; exports.runDriverTests = runDriverTests;
+//# sourceMappingURL=mod.cjs.map