rivetkit 2.0.2 → 2.0.3

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

@@ -0,0 +1,4619 @@
+import {
+  getPort
+} from "../chunk-6PDXBYI5.js";
+import {
+  actor,
+  createInlineClientDriver,
+  createManagerRouter
+} from "../chunk-OV6AYD4S.js";
+import {
+  createActorInspectorClient,
+  createManagerInspectorClient
+} from "../chunk-42I3OZ3Q.js";
+import {
+  createClient
+} from "../chunk-UVUPOS46.js";
+import {
+  ActorError,
+  createClientWithDriver
+} from "../chunk-EGVZZFE2.js";
+import "../chunk-FLMTTN27.js";
+import {
+  importWebSocket
+} from "../chunk-PO4VLDWA.js";
+import {
+  RunConfigSchema
+} from "../chunk-KJCJLKRM.js";
+import "../chunk-VRRHBNJC.js";
+import {
+  HEADER_ACTOR_QUERY,
+  HEADER_CONN_PARAMS,
+  HEADER_ENCODING,
+  assertUnreachable
+} from "../chunk-4NSUQZ2H.js";
+import {
+  getLogger
+} from "../chunk-XFSS33EQ.js";
+import "../chunk-3H7O2A7I.js";
+import {
+  INTERNAL_ERROR_CODE,
+  INTERNAL_ERROR_DESCRIPTION
+} from "../chunk-INGJP237.js";
+
+// src/driver-test-suite/mod.ts
+import { serve as honoServe } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { bundleRequire } from "bundle-require";
+import invariant from "invariant";
+import { describe as describe23 } from "vitest";
+
+// src/driver-test-suite/tests/action-features.ts
+import { describe, expect, test } from "vitest";
+
+// src/driver-test-suite/utils.ts
+import { resolve } from "path";
+import { vi } from "vitest";
+
+// src/driver-test-suite/test-inline-client-driver.ts
+import * as cbor from "cbor-x";
+
+// src/driver-test-suite/log.ts
+var LOGGER_NAME = "test-suite";
+function logger() {
+  return getLogger(LOGGER_NAME);
+}
+
+// src/driver-test-suite/test-inline-client-driver.ts
+function createTestInlineClientDriver(endpoint, transport) {
+  return {
+    action: async (_c, actorQuery, encoding, params, name, args) => {
+      return makeInlineRequest(
+        endpoint,
+        encoding,
+        transport,
+        "action",
+        [void 0, actorQuery, encoding, params, name, args]
+      );
+    },
+    resolveActorId: async (_c, actorQuery, encodingKind, params) => {
+      return makeInlineRequest(
+        endpoint,
+        encodingKind,
+        transport,
+        "resolveActorId",
+        [void 0, actorQuery, encodingKind, params]
+      );
+    },
+    connectWebSocket: async (_c, actorQuery, encodingKind, params) => {
+      const WebSocket2 = await importWebSocket();
+      logger().debug("creating websocket connection via test inline driver", {
+        actorQuery,
+        encodingKind
+      });
+      const wsUrl = new URL(
+        `${endpoint}/registry/.test/inline-driver/connect-websocket`
+      );
+      wsUrl.searchParams.set("actorQuery", JSON.stringify(actorQuery));
+      if (params !== void 0)
+        wsUrl.searchParams.set("params", JSON.stringify(params));
+      wsUrl.searchParams.set("encodingKind", encodingKind);
+      const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+      logger().debug("connecting to websocket", { url: finalWsUrl });
+      const ws = new WebSocket2(finalWsUrl, [
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      return ws;
+    },
+    connectSse: async (_c, actorQuery, encodingKind, params) => {
+      logger().debug("creating sse connection via test inline driver", {
+        actorQuery,
+        encodingKind,
+        params
+      });
+      const EventSourceImport = await import("eventsource");
+      const EventSourceConstructor = EventSourceImport.default || EventSourceImport;
+      const actorQueryParam = encodeURIComponent(JSON.stringify(actorQuery));
+      const encodingParam = encodeURIComponent(encodingKind);
+      const paramsParam = params ? encodeURIComponent(JSON.stringify(params)) : null;
+      const sseUrl = new URL(
+        `${endpoint}/registry/.test/inline-driver/connect-sse`
+      );
+      sseUrl.searchParams.set("actorQueryRaw", actorQueryParam);
+      sseUrl.searchParams.set("encodingKind", encodingParam);
+      if (paramsParam) {
+        sseUrl.searchParams.set("params", paramsParam);
+      }
+      logger().debug("connecting to sse", { url: sseUrl.toString() });
+      const eventSource = new EventSourceConstructor(sseUrl.toString());
+      await new Promise((resolve2, reject) => {
+        eventSource.onopen = () => {
+          logger().debug("sse connection established");
+          resolve2();
+        };
+        eventSource.onerror = (event) => {
+          logger().error("sse connection failed", { event });
+          reject(new Error("Failed to establish SSE connection"));
+        };
+        setTimeout(() => {
+          if (eventSource.readyState !== EventSourceConstructor.OPEN) {
+            reject(new Error("SSE connection timed out"));
+          }
+        }, 1e4);
+      });
+      return eventSource;
+    },
+    sendHttpMessage: async (_c, actorId, encoding, connectionId, connectionToken, message) => {
+      var _a;
+      logger().debug("sending http message via test inline driver", {
+        actorId,
+        encoding,
+        connectionId,
+        transport
+      });
+      const result = await fetch(
+        `${endpoint}/registry/.test/inline-driver/call`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            encoding,
+            transport,
+            method: "sendHttpMessage",
+            args: [
+              void 0,
+              actorId,
+              encoding,
+              connectionId,
+              connectionToken,
+              message
+            ]
+          })
+        }
+      );
+      if (!result.ok) {
+        throw new Error(`Failed to send HTTP message: ${result.statusText}`);
+      }
+      await ((_a = result.body) == null ? void 0 : _a.cancel());
+    },
+    rawHttpRequest: async (_c, actorQuery, encoding, params, path, init) => {
+      var _a;
+      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+      logger().debug("sending raw http request via test inline driver", {
+        actorQuery,
+        encoding,
+        path: normalizedPath
+      });
+      const url = `${endpoint}/registry/.test/inline-driver/raw-http/${normalizedPath}`;
+      logger().debug("rewriting http url", {
+        from: path,
+        to: url
+      });
+      const headers = new Headers(init.headers);
+      headers.set(HEADER_ACTOR_QUERY, JSON.stringify(actorQuery));
+      headers.set(HEADER_ENCODING, encoding);
+      if (params !== void 0) {
+        headers.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+      }
+      const response = await fetch(url, {
+        ...init,
+        headers
+      });
+      if (!response.ok && ((_a = response.headers.get("content-type")) == null ? void 0 : _a.includes("application/json"))) {
+        try {
+          const clonedResponse = response.clone();
+          const errorData = await clonedResponse.json();
+          if (errorData.error) {
+            if (typeof errorData.error === "object") {
+              throw new ActorError(
+                errorData.error.code,
+                errorData.error.message,
+                errorData.error.metadata
+              );
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof ActorError)) {
+            return response;
+          }
+          throw e;
+        }
+      }
+      return response;
+    },
+    rawWebSocket: async (_c, actorQuery, encoding, params, path, protocols) => {
+      logger().debug("test inline driver rawWebSocket called");
+      const WebSocket2 = await importWebSocket();
+      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+      logger().debug(
+        "creating raw websocket connection via test inline driver",
+        {
+          actorQuery,
+          encoding,
+          path: normalizedPath,
+          protocols
+        }
+      );
+      const wsUrl = new URL(
+        `${endpoint}/registry/.test/inline-driver/raw-websocket`
+      );
+      wsUrl.searchParams.set("actorQuery", JSON.stringify(actorQuery));
+      if (params !== void 0)
+        wsUrl.searchParams.set("params", JSON.stringify(params));
+      wsUrl.searchParams.set("encodingKind", encoding);
+      wsUrl.searchParams.set("path", normalizedPath);
+      if (protocols !== void 0)
+        wsUrl.searchParams.set("protocols", JSON.stringify(protocols));
+      const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+      logger().debug("connecting to raw websocket", { url: finalWsUrl });
+      logger().debug("rewriting websocket url", {
+        from: path,
+        to: finalWsUrl
+      });
+      const ws = new WebSocket2(finalWsUrl, [
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      logger().debug("test inline driver created websocket", {
+        readyState: ws.readyState,
+        url: ws.url
+      });
+      return ws;
+    }
+  };
+}
+async function makeInlineRequest(endpoint, encoding, transport, method, args) {
+  logger().debug("sending inline request", {
+    encoding,
+    transport,
+    method,
+    args
+  });
+  const response = await fetch(
+    `${endpoint}/registry/.test/inline-driver/call`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: cbor.encode({
+        encoding,
+        transport,
+        method,
+        args
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to call inline ${method}: ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  const callResponse = cbor.decode(
+    new Uint8Array(buffer)
+  );
+  if ("ok" in callResponse) {
+    return callResponse.ok;
+  } else if ("err" in callResponse) {
+    throw new ActorError(
+      callResponse.err.code,
+      callResponse.err.message,
+      callResponse.err.metadata
+    );
+  } else {
+    assertUnreachable(callResponse);
+  }
+}
+
+// src/driver-test-suite/utils.ts
+var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
+async function setupDriverTest(c, driverTestConfig) {
+  if (!driverTestConfig.useRealTimers) {
+    vi.useFakeTimers();
+    vi.setSystemTime(FAKE_TIME);
+  }
+  const projectPath = resolve(__dirname, "../../fixtures/driver-test-suite");
+  const { endpoint, cleanup } = await driverTestConfig.start(projectPath);
+  c.onTestFinished(cleanup);
+  let client;
+  if (driverTestConfig.clientType === "http") {
+    client = createClient(endpoint, {
+      transport: driverTestConfig.transport
+    });
+  } else if (driverTestConfig.clientType === "inline") {
+    const clientDriver = createTestInlineClientDriver(
+      endpoint,
+      driverTestConfig.transport ?? "websocket"
+    );
+    client = createClientWithDriver(clientDriver);
+  } else {
+    assertUnreachable(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 {
+    vi.advanceTimersByTime(ms);
+    return Promise.resolve();
+  }
+}
+
+// src/driver-test-suite/tests/action-features.ts
+function runActionFeaturesTests(driverTestConfig) {
+  describe("Action Features", () => {
+    describe("Action Timeouts", () => {
+      const usesFakeTimers = !driverTestConfig.useRealTimers;
+      test("should timeout actions that exceed the configured timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const quickResult = await client.shortTimeoutActor.getOrCreate().quickAction();
+        expect(quickResult).toBe("quick response");
+        await expect(
+          client.shortTimeoutActor.getOrCreate().slowAction()
+        ).rejects.toThrow("Action timed out");
+      });
+      test("should respect the default timeout", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const result = await client.defaultTimeoutActor.getOrCreate().normalAction();
+        expect(result).toBe("normal response");
+      });
+      test("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();
+        expect(result).toBe("sync response");
+      });
+      test("should allow configuring different timeouts for different actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        await expect(
+          client.shortTimeoutActor.getOrCreate().slowAction()
+        ).rejects.toThrow("Action timed out");
+        const result = await client.longTimeoutActor.getOrCreate().delayedAction();
+        expect(result).toBe("delayed response");
+      });
+    });
+    describe("Action Sync & Async", () => {
+      test("should support synchronous actions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.syncActionActor.getOrCreate();
+        let result = await instance.increment(5);
+        expect(result).toBe(5);
+        result = await instance.increment(3);
+        expect(result).toBe(8);
+        const info = await instance.getInfo();
+        expect(info.currentValue).toBe(8);
+        expect(typeof info.timestamp).toBe("number");
+        await instance.reset();
+        result = await instance.increment(0);
+        expect(result).toBe(0);
+      });
+      test("should support asynchronous actions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.asyncActionActor.getOrCreate();
+        const result = await instance.delayedIncrement(5);
+        expect(result).toBe(5);
+        const data = await instance.fetchData("test-123");
+        expect(data.id).toBe("test-123");
+        expect(typeof data.timestamp).toBe("number");
+        const success = await instance.asyncWithError(false);
+        expect(success).toBe("Success");
+        try {
+          await instance.asyncWithError(true);
+          expect.fail("did not error");
+        } catch (error) {
+          expect(error.message).toBe("Intentional error");
+        }
+      });
+      test("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();
+        expect(resolvedValue).toBe("resolved value");
+        const delayedValue = await instance.delayedPromise();
+        expect(delayedValue).toBe("delayed value");
+        await expect(instance.rejectedPromise()).rejects.toThrow(
+          "promised rejection"
+        );
+        const results = await instance.getResults();
+        expect(results).toContain("delayed");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-auth.ts
+import { describe as describe2, expect as expect2, test as test2 } from "vitest";
+function runActorAuthTests(driverTestConfig) {
+  describe2("Actor Authentication Tests", () => {
+    describe2("Basic Authentication", () => {
+      test2("should allow access with valid auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.authActor.getOrCreate(void 0, {
+          params: { apiKey: "valid-api-key" }
+        });
+        const authData = await instance.getUserAuth();
+        if (driverTestConfig.clientType === "inline") {
+          expect2(authData).toBeUndefined();
+        } else {
+          expect2(authData).toEqual({
+            userId: "user123",
+            token: "valid-api-key"
+          });
+        }
+        const requests = await instance.getRequests();
+        expect2(requests).toBe(1);
+      });
+      test2("should deny access with invalid auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.authActor.getOrCreate();
+        if (driverTestConfig.clientType === "inline") {
+          const requests = await instance.getRequests();
+          expect2(typeof requests).toBe("number");
+        } else {
+          try {
+            await instance.getRequests();
+            expect2.fail("Expected authentication error");
+          } catch (error) {
+            expect2(error.code).toBe("missing_auth");
+          }
+        }
+      });
+      test2("should expose auth data on connection", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.authActor.getOrCreate(void 0, {
+          params: { apiKey: "valid-api-key" }
+        });
+        const authData = await instance.getUserAuth();
+        if (driverTestConfig.clientType === "inline") {
+          expect2(authData).toBeUndefined();
+        } else {
+          expect2(authData).toBeDefined();
+          expect2(authData.userId).toBe("user123");
+          expect2(authData.token).toBe("valid-api-key");
+        }
+      });
+    });
+    describe2("Intent-Based Authentication", () => {
+      test2("should allow get operations for any role", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const createdInstance = await client.intentAuthActor.create(["foo"], {
+          params: { role: "admin" }
+        });
+        const actorId = await createdInstance.resolve();
+        if (driverTestConfig.clientType === "inline") {
+          const instance = client.intentAuthActor.getForId(actorId);
+          const value = await instance.getValue();
+          expect2(value).toBe(0);
+        } else {
+          const instance = client.intentAuthActor.getForId(actorId, {
+            params: { role: "user" }
+            // Actions require user or admin role
+          });
+          const value = await instance.getValue();
+          expect2(value).toBe(0);
+        }
+      });
+      test2("should require admin role for create operations", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        if (driverTestConfig.clientType === "inline") {
+          const instance = client.intentAuthActor.getOrCreate(void 0, {
+            params: { role: "user" }
+          });
+          const value = await instance.getValue();
+          expect2(value).toBe(0);
+        } else {
+          try {
+            const instance = client.intentAuthActor.getOrCreate(void 0, {
+              params: { role: "user" }
+            });
+            await instance.getValue();
+            expect2.fail("Expected permission error for create operation");
+          } catch (error) {
+            expect2(error.code).toBe("insufficient_permissions");
+            expect2(error.message).toContain(
+              "Admin role required"
+            );
+          }
+        }
+      });
+      test2("should allow actions for user and admin roles", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const createdInstance = await client.intentAuthActor.create(["foo"], {
+          params: { role: "admin" }
+        });
+        const actorId = await createdInstance.resolve();
+        const instance = client.intentAuthActor.getForId(actorId, {
+          params: { role: "guest" }
+        });
+        if (driverTestConfig.clientType === "inline") {
+          const result = await instance.setValue(42);
+          expect2(result).toBe(42);
+        } else {
+          try {
+            await instance.setValue(42);
+            expect2.fail("Expected permission error for action");
+          } catch (error) {
+            expect2(error.code).toBe("insufficient_permissions");
+            expect2(error.message).toContain(
+              "User or admin role required"
+            );
+          }
+        }
+      });
+    });
+    describe2("Public Access", () => {
+      test2("should allow access with empty onAuth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.publicActor.getOrCreate();
+        const visitors = await instance.visit();
+        expect2(visitors).toBe(1);
+        const visitors2 = await instance.visit();
+        expect2(visitors2).toBe(2);
+      });
+      test2("should deny access without onAuth defined", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.noAuthActor.getOrCreate();
+        if (driverTestConfig.clientType === "inline") {
+          const value = await instance.getValue();
+          expect2(value).toBe(42);
+        } else {
+          try {
+            await instance.getValue();
+            expect2.fail(
+              "Expected access to be denied for actor without onAuth"
+            );
+          } catch (error) {
+            expect2(error.code).toBe("forbidden");
+          }
+        }
+      });
+    });
+    describe2("Async Authentication", () => {
+      test2("should handle promise-based auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.asyncAuthActor.getOrCreate(void 0, {
+          params: { token: "valid" }
+        });
+        const result = await instance.increment();
+        expect2(result).toBe(1);
+        const authData = await instance.getAuthData();
+        if (driverTestConfig.clientType === "inline") {
+          expect2(authData).toBeUndefined();
+        } else {
+          expect2(authData).toBeDefined();
+          expect2(authData.userId).toBe("user-valid");
+          expect2(authData.validated).toBe(true);
+        }
+      });
+      test2("should handle async auth failures", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.asyncAuthActor.getOrCreate();
+        if (driverTestConfig.clientType === "inline") {
+          const result = await instance.increment();
+          expect2(result).toBe(1);
+        } else {
+          try {
+            await instance.increment();
+            expect2.fail("Expected async auth failure");
+          } catch (error) {
+            expect2(error.code).toBe("missing_token");
+          }
+        }
+      });
+    });
+    describe2("Authentication Across Transports", () => {
+      if (driverTestConfig.transport === "websocket") {
+        test2("should authenticate WebSocket connections", async (c) => {
+          const { client } = await setupDriverTest(c, driverTestConfig);
+          const instance = client.authActor.getOrCreate(void 0, {
+            params: { apiKey: "valid-api-key" }
+          });
+          const authData = await instance.getUserAuth();
+          expect2(authData).toBeDefined();
+          expect2(authData.userId).toBe("user123");
+        });
+      }
+      test2("should authenticate HTTP actions", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.authActor.getOrCreate(void 0, {
+          params: { apiKey: "valid-api-key" }
+        });
+        const requests = await instance.getRequests();
+        expect2(typeof requests).toBe("number");
+      });
+    });
+    describe2("Error Handling", () => {
+      test2("should handle auth errors gracefully", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.authActor.getOrCreate();
+        if (driverTestConfig.clientType === "inline") {
+          const requests = await instance.getRequests();
+          expect2(typeof requests).toBe("number");
+        } else {
+          try {
+            await instance.getRequests();
+            expect2.fail("Expected authentication error");
+          } catch (error) {
+            const actorError = error;
+            expect2(actorError.code).toBeDefined();
+            expect2(actorError.message).toBeDefined();
+          }
+        }
+      });
+      test2("should preserve error details for debugging", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.asyncAuthActor.getOrCreate();
+        if (driverTestConfig.clientType === "inline") {
+          const result = await instance.increment();
+          expect2(result).toBe(1);
+        } else {
+          try {
+            await instance.increment();
+            expect2.fail("Expected token error");
+          } catch (error) {
+            const actorError = error;
+            expect2(actorError.code).toBe("missing_token");
+            expect2(actorError.message).toBe("Token required");
+          }
+        }
+      });
+    });
+    describe2("Raw HTTP Authentication", () => {
+      test2("should allow raw HTTP access with valid auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawHttpAuthActor.getOrCreate(void 0, {
+          params: { apiKey: "valid-api-key" }
+        });
+        const response = await instance.fetch("api/auth-info");
+        expect2(response.ok).toBe(true);
+        const data = await response.json();
+        expect2(data.message).toBe("Authenticated request");
+        expect2(data.requestCount).toBe(1);
+        const count = await instance.getRequestCount();
+        expect2(count).toBe(1);
+      });
+      test2("should deny raw HTTP access without auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawHttpAuthActor.getOrCreate();
+        const response = await instance.fetch("api/protected");
+        if (driverTestConfig.clientType === "inline") {
+          expect2(response.ok).toBe(true);
+          expect2(response.status).toBe(200);
+        } else {
+          expect2(response.ok).toBe(false);
+          expect2(response.status).toBe(400);
+        }
+        try {
+          const errorData = await response.json();
+          expect2(errorData.c || errorData.code).toBe("missing_auth");
+        } catch {
+        }
+      });
+      test2("should deny raw HTTP for actors without onAuth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawHttpNoAuthActor.getOrCreate();
+        const response = await instance.fetch("api/test");
+        if (driverTestConfig.clientType === "inline") {
+          expect2(response.ok).toBe(true);
+          expect2(response.status).toBe(200);
+        } else {
+          expect2(response.ok).toBe(false);
+          expect2(response.status).toBe(403);
+        }
+        try {
+          const errorData = await response.json();
+          expect2(errorData.c || errorData.code).toBe("forbidden");
+        } catch {
+        }
+      });
+      test2("should allow public raw HTTP access", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawHttpPublicActor.getOrCreate();
+        const response = await instance.fetch("api/visit");
+        expect2(response.ok).toBe(true);
+        const data = await response.json();
+        expect2(data.message).toBe("Welcome visitor!");
+        expect2(data.count).toBe(1);
+        const response2 = await instance.fetch("api/visit");
+        const data2 = await response2.json();
+        expect2(data2.count).toBe(2);
+      });
+      test2("should handle custom auth in onFetch", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawHttpCustomAuthActor.getOrCreate();
+        const response1 = await instance.fetch("api/data");
+        expect2(response1.ok).toBe(false);
+        expect2(response1.status).toBe(401);
+        const error1 = await response1.json();
+        expect2(error1.error).toBe("Unauthorized");
+        const response2 = await instance.fetch("api/data", {
+          headers: {
+            Authorization: "Bearer wrong-token"
+          }
+        });
+        expect2(response2.ok).toBe(false);
+        expect2(response2.status).toBe(403);
+        const response3 = await instance.fetch("api/data", {
+          headers: {
+            Authorization: "Bearer custom-token"
+          }
+        });
+        expect2(response3.ok).toBe(true);
+        const data = await response3.json();
+        expect2(data.message).toBe("Authorized!");
+        expect2(data.authorized).toBe(1);
+        const stats = await instance.getStats();
+        expect2(stats.authorized).toBe(1);
+        expect2(stats.unauthorized).toBe(2);
+      });
+    });
+    describe2("Raw WebSocket Authentication", () => {
+      test2("should allow raw WebSocket access with valid auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawWebSocketAuthActor.getOrCreate(void 0, {
+          params: { apiKey: "valid-api-key" }
+        });
+        const ws = await instance.websocket();
+        const welcomePromise = new Promise((resolve2, reject) => {
+          ws.addEventListener("message", (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type === "welcome") {
+              resolve2(data);
+            }
+          });
+          ws.addEventListener("close", () => reject("closed"));
+        });
+        const welcomeData = await welcomePromise;
+        expect2(welcomeData.message).toBe("Authenticated WebSocket connection");
+        expect2(welcomeData.connectionCount).toBe(1);
+        ws.close();
+      });
+      test2("should deny raw WebSocket access without auth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawWebSocketAuthActor.getOrCreate();
+        try {
+          await instance.websocket();
+          expect2.fail("Expected authentication error");
+        } catch (error) {
+          expect2(error).toBeDefined();
+        }
+      });
+      test2("should deny raw WebSocket for actors without onAuth", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawWebSocketNoAuthActor.getOrCreate();
+        try {
+          await instance.websocket();
+          expect2.fail("Expected forbidden error");
+        } catch (error) {
+          expect2(error).toBeDefined();
+        }
+      });
+      test2("should allow public raw WebSocket access", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawWebSocketPublicActor.getOrCreate();
+        const ws = await instance.websocket();
+        const welcomePromise = new Promise((resolve2, reject) => {
+          ws.addEventListener("message", (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type === "welcome") {
+              resolve2(data);
+            }
+          });
+          ws.addEventListener("close", reject);
+        });
+        const welcomeData = await welcomePromise;
+        expect2(welcomeData.message).toBe("Public WebSocket connection");
+        expect2(welcomeData.visitorNumber).toBe(1);
+        ws.close();
+      });
+      test2("should handle custom auth in onWebSocket", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.rawWebSocketCustomAuthActor.getOrCreate();
+        try {
+          const ws1 = await instance.websocket();
+          const errorPromise = new Promise((resolve2, reject) => {
+            ws1.addEventListener("message", (event) => {
+              const data = JSON.parse(event.data);
+              if (data.type === "error") {
+                resolve2(data);
+              }
+            });
+            ws1.addEventListener("close", reject);
+          });
+          const errorData = await errorPromise;
+          expect2(errorData.type).toBe("error");
+          expect2(errorData.message).toBe("Unauthorized");
+        } catch (error) {
+          expect2(error).toBeDefined();
+        }
+        const ws2 = await instance.websocket("?token=custom-ws-token");
+        const authPromise = new Promise((resolve2, reject) => {
+          ws2.addEventListener("message", (event) => {
+            const data = JSON.parse(event.data);
+            if (data.type === "authorized") {
+              resolve2(data);
+            }
+          });
+          ws2.addEventListener("close", reject);
+        });
+        const authData = await authPromise;
+        expect2(authData.message).toBe("Welcome authenticated user!");
+        ws2.close();
+        const stats = await instance.getStats();
+        expect2(stats.authorized).toBeGreaterThanOrEqual(1);
+        expect2(stats.unauthorized).toBeGreaterThanOrEqual(1);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-conn.ts
+import { describe as describe3, expect as expect3, test as test3 } from "vitest";
+function runActorConnTests(driverTestConfig) {
+  describe3("Actor Connection Tests", () => {
+    describe3("Connection Methods", () => {
+      test3("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);
+        expect3(count).toBe(5);
+        await connection.dispose();
+      });
+      test3("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();
+        expect3(count).toBe(3);
+        await connection.dispose();
+      });
+      test3("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);
+        expect3(count).toBe(7);
+        await connection.dispose();
+      });
+      test3("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);
+        expect3(count).toBe(9);
+        await connection.dispose();
+      });
+    });
+    describe3("Event Communication", () => {
+      test3("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();
+      });
+      test3("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);
+        expect3(receivedEvents).toContain(5);
+        expect3(receivedEvents).toContain(8);
+        await connection.dispose();
+      });
+      test3("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);
+        expect3(receivedEvents).toEqual([5]);
+        expect3(receivedEvents).not.toContain(8);
+        await connection.dispose();
+      });
+      test3("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);
+        expect3(receivedEvents).toEqual([5]);
+        expect3(receivedEvents).not.toContain(8);
+        await connection.dispose();
+      });
+    });
+    describe3("Connection Parameters", () => {
+      test3("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();
+        expect3(initializers).toContain("user1");
+        expect3(initializers).toContain("user2");
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+    describe3("Lifecycle Hooks", () => {
+      test3("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();
+        expect3(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
+        await connection.dispose();
+        const handle = client.counterWithLifecycle.getOrCreate([
+          "test-lifecycle"
+        ]);
+        const finalEvents = await handle.getEvents();
+        expect3(finalEvents).toBeOneOf([
+          // Still active
+          ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
+          // Went to sleep and woke back up
+          [
+            "onStart",
+            "onBeforeConnect",
+            "onConnect",
+            "onDisconnect",
+            "onStart"
+          ]
+        ]);
+      });
+    });
+    describe3("Connection Liveness", () => {
+      test3.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();
+        expect3(counter).toBe(10);
+        const connectionsStatusBeforeKill = await handle.getWsConnectionsLiveness();
+        expect3(connectionsStatusBeforeKill).toHaveLength(2);
+        expect3(connectionsStatusBeforeKill).toContainEqual(
+          expect3.objectContaining({
+            id: connAId,
+            status: "connected",
+            lastSeen: FAKE_TIME.getTime()
+          })
+        );
+        expect3(connectionsStatusBeforeKill).toContainEqual(
+          expect3.objectContaining({
+            id: connBId,
+            status: "connected",
+            lastSeen: FAKE_TIME.getTime()
+          })
+        );
+        await handle.kill(connAId);
+        const connectionsStatusAfterKill = await handle.getWsConnectionsLiveness();
+        expect3(connectionsStatusAfterKill).toEqual(
+          expect3.arrayContaining([
+            expect3.objectContaining({
+              id: connAId,
+              status: "reconnecting",
+              lastSeen: FAKE_TIME.getTime()
+            }),
+            expect3.objectContaining({
+              id: connBId,
+              status: "connected",
+              lastSeen: FAKE_TIME.getTime()
+            })
+          ])
+        );
+        await waitFor(driverTestConfig, 5e3);
+        const connectionsStatusAfterCleanup = await handle.getWsConnectionsLiveness();
+        expect3(connectionsStatusAfterCleanup).not.toContainEqual(
+          expect3.objectContaining({
+            id: connAId
+          })
+        );
+        expect3(connectionsStatusAfterCleanup).toContainEqual(
+          expect3.objectContaining({
+            id: connBId
+          })
+        );
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-conn-state.ts
+import { describe as describe4, expect as expect4, test as test4, vi as vi2 } from "vitest";
+function runActorConnStateTests(driverTestConfig) {
+  describe4("Actor Connection State Tests", () => {
+    describe4("Connection State Initialization", () => {
+      test4("should retrieve connection state", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const connection = client.connStateActor.getOrCreate().connect();
+        const connState = await connection.getConnectionState();
+        expect4(connState.id).toBeDefined();
+        expect4(connState.username).toBeDefined();
+        expect4(connState.role).toBeDefined();
+        expect4(connState.counter).toBeDefined();
+        expect4(connState.createdAt).toBeDefined();
+        await connection.dispose();
+      });
+      test4("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();
+        expect4(connState.username).toBe("testuser");
+        expect4(connState.role).toBe("admin");
+        await connection.dispose();
+      });
+    });
+    describe4("Connection State Management", () => {
+      test4("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();
+        expect4(state1.counter).toBe(5);
+        expect4(state2.counter).toBe(10);
+        expect4(state1.username).toBe("user1");
+        expect4(state2.username).toBe("user2");
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+      test4("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();
+        expect4(connectionIds.length).toBeGreaterThanOrEqual(2);
+        expect4(connectionIds).toContain(state1.id);
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+      test4("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();
+        expect4(allStates.length).toBeGreaterThanOrEqual(2);
+        const ids = allStates.map((state) => state.id);
+        const uniqueIds = [...new Set(ids)];
+        expect4(uniqueIds.length).toBe(ids.length);
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+    describe4("Connection Lifecycle", () => {
+      test4("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();
+        expect4(connectionIds).toContain(connState.id);
+        const initialDisconnections = await conn.getDisconnectionCount();
+        await conn.dispose();
+        const newConn = handle.connect();
+        await vi2.waitFor(async () => {
+          const newDisconnections = await newConn.getDisconnectionCount();
+          expect4(newDisconnections).toBeGreaterThan(initialDisconnections);
+        });
+        await newConn.dispose();
+      });
+      test4("should update connection state", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const conn = client.connStateActor.getOrCreate().connect();
+        const initialState = await conn.getConnectionState();
+        expect4(initialState.username).toBe("anonymous");
+        const updatedState = await conn.updateConnection({
+          username: "newname",
+          role: "moderator"
+        });
+        expect4(updatedState.username).toBe("newname");
+        expect4(updatedState.role).toBe("moderator");
+        const latestState = await conn.getConnectionState();
+        expect4(latestState.username).toBe("newname");
+        expect4(latestState.role).toBe("moderator");
+        await conn.dispose();
+      });
+    });
+    describe4("Connection Communication", () => {
+      test4("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"
+        );
+        expect4(success).toBe(true);
+        expect4(receivedMessages.length).toBe(1);
+        expect4(receivedMessages[0].from).toBe(state1.id);
+        expect4(receivedMessages[0].message).toBe("Hello from conn1");
+        await conn1.dispose();
+        await conn2.dispose();
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-driver.ts
+import { describe as describe8 } from "vitest";
+
+// src/driver-test-suite/tests/actor-schedule.ts
+import { describe as describe5, expect as expect5, test as test5 } from "vitest";
+function runActorScheduleTests(driverTestConfig) {
+  var _a;
+  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+    "Actor Schedule Tests",
+    () => {
+      describe5("Scheduled Alarms", () => {
+        test5("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();
+          expect5(lastRun).toBeGreaterThan(0);
+          expect5(scheduledCount).toBe(1);
+        });
+        test5("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();
+          expect5(lastRun).toBeGreaterThan(0);
+          expect5(scheduledCount).toBe(1);
+        });
+        test5("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();
+          expect5(initialCount).toBe(0);
+          await waitFor(driverTestConfig, 200);
+          const scheduledCount = await newInstance.getScheduledCount();
+          expect5(scheduledCount).toBe(1);
+        });
+        test5("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();
+          expect5(history1).toEqual(["first"]);
+          await waitFor(driverTestConfig, 200);
+          const history2 = await scheduled.getTaskHistory();
+          expect5(history2).toEqual(["first", "second"]);
+          await waitFor(driverTestConfig, 200);
+          const history3 = await scheduled.getTaskHistory();
+          expect5(history3).toEqual(["first", "second", "third"]);
+        });
+      });
+    }
+  );
+}
+
+// src/driver-test-suite/tests/actor-sleep.ts
+import { describe as describe6, expect as expect6, test as test6 } from "vitest";
+
+// fixtures/driver-test-suite/sleep.ts
+var SLEEP_TIMEOUT = 500;
+var sleep = actor({
+  onAuth: () => {
+  },
+  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 = actor({
+  onAuth: () => {
+  },
+  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 = actor({
+  onAuth: () => {
+  },
+  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("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 = actor({
+  onAuth: () => {
+  },
+  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("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 {
+          websocket.send(data);
+        }
+      }
+    });
+    websocket.addEventListener("close", () => {
+      c.state.connectionCount -= 1;
+      c.log.info("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 = actor({
+  onAuth: () => {
+  },
+  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;
+  describe6.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    test6("actor sleep persists state", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.triggerSleep();
+      await waitFor(driverTestConfig, 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("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();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.triggerSleep();
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, 100);
+      const sleepActor2 = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("actor automatically sleeps after timeout", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("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();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      const sleepActor2 = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("rpc calls keep actor awake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("alarms keep actor awake", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.setAlarm(SLEEP_TIMEOUT - 100);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+    });
+    test6("alarms wake actors", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleep.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.setAlarm(SLEEP_TIMEOUT + 100);
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("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();
+        expect6(sleepCount).toBe(0);
+        expect6(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();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await sleepActor.dispose();
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor2.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("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();
+        expect6(sleepCount).toBe(0);
+        expect6(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);
+          }
+        };
+      });
+      expect6(counts.sleepCount).toBe(0);
+      expect6(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();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("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();
+        expect6(sleepCount).toBe(0);
+        expect6(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();
+      expect6(result.completed).toBe(true);
+      {
+        const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+        expect6(requestCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(1);
+        expect6(startCount).toBe(2);
+      }
+    });
+    test6("noSleep option disables sleeping", async (c) => {
+      const { client } = await setupDriverTest(c, driverTestConfig);
+      const sleepActor = client.sleepWithNoSleepOption.getOrCreate();
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+      await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+      {
+        const { startCount, sleepCount } = await sleepActor.getCounts();
+        expect6(sleepCount).toBe(0);
+        expect6(startCount).toBe(1);
+      }
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-state.ts
+import { describe as describe7, expect as expect7, test as test7 } from "vitest";
+function runActorStateTests(driverTestConfig) {
+  describe7("Actor State Tests", () => {
+    describe7("State Persistence", () => {
+      test7("persists state between actor instances", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const counterInstance = client.counter.getOrCreate();
+        const initialCount = await counterInstance.increment(5);
+        expect7(initialCount).toBe(5);
+        const sameInstance = client.counter.getOrCreate();
+        const persistedCount = await sameInstance.increment(3);
+        expect7(persistedCount).toBe(8);
+      });
+      test7("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);
+        expect7(persistedCount).toBe(5);
+      });
+      test7("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);
+        expect7(countA).toBe(5);
+        expect7(countB).toBe(10);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-driver.ts
+function runActorDriverTests(driverTestConfig) {
+  describe8("Actor Driver Tests", () => {
+    runActorStateTests(driverTestConfig);
+    runActorScheduleTests(driverTestConfig);
+  });
+}
+function runActorDriverTestsWithTransport(driverTestConfig) {
+  describe8("Actor Driver Tests", () => {
+    runActorSleepTests(driverTestConfig);
+  });
+}
+
+// src/driver-test-suite/tests/actor-error-handling.ts
+import { describe as describe9, expect as expect8, test as test8 } from "vitest";
+function runActorErrorHandlingTests(driverTestConfig) {
+  describe9("Actor Error Handling Tests", () => {
+    describe9("UserError Handling", () => {
+      test8("should handle simple UserError with message", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwSimpleError();
+          expect8(true).toBe(false);
+        } catch (error) {
+          expect8(error.message).toBe("Simple error message");
+          expect8(error.code).toBe("user_error");
+          expect8(error.metadata).toBeUndefined();
+        }
+      });
+      test8("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();
+          expect8(true).toBe(false);
+        } catch (error) {
+          expect8(error.message).toBe("Detailed error message");
+          expect8(error.code).toBe("detailed_error");
+          expect8(error.metadata).toBeDefined();
+          expect8(error.metadata.reason).toBe("test");
+          expect8(error.metadata.timestamp).toBeDefined();
+        }
+      });
+    });
+    describe9("Internal Error Handling", () => {
+      test8("should convert internal errors to safe format", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.errorHandlingActor.getOrCreate();
+        try {
+          await handle.throwInternalError();
+          expect8(true).toBe(false);
+        } catch (error) {
+          if (driverTestConfig.clientType === "http") {
+            expect8(error.code).toBe(INTERNAL_ERROR_CODE);
+            expect8(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+          } else if (driverTestConfig.clientType === "inline") {
+            expect8(error.code).toBe(INTERNAL_ERROR_CODE);
+            expect8(error.message).toBe("This is an internal error");
+          } else {
+            assertUnreachable(driverTestConfig.clientType);
+          }
+        }
+      });
+    });
+    describe9.skip("Action Timeout", () => {
+      test8("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;
+          expect8(true).toBe(false);
+        } catch (error) {
+          expect8(error.message).toMatch(/timed out/i);
+        }
+      });
+      test8("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);
+        expect8(result).toBe("Completed after 200ms");
+      });
+      test8("should respect different timeouts for different actors", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        try {
+          await client.customTimeoutActor.getOrCreate().slowAction();
+          expect8(true).toBe(false);
+        } catch (error) {
+          expect8(error.message).toMatch(/timed out/i);
+        }
+        const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
+        expect8(quickResult).toBe("Quick action completed");
+      });
+    });
+    describe9("Error Recovery", () => {
+      test8("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();
+        expect8(result).toBe("success");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-handle.ts
+import { describe as describe10, expect as expect9, test as test9 } from "vitest";
+function runActorHandleTests(driverTestConfig) {
+  describe10("Actor Handle Tests", () => {
+    describe10("Access Methods", () => {
+      test9("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);
+        expect9(count).toBe(5);
+        const retrievedCount = await handle.getCount();
+        expect9(retrievedCount).toBe(5);
+      });
+      test9("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();
+        expect9(count).toBe(3);
+        const newCount = await idHandle.increment(4);
+        expect9(newCount).toBe(7);
+      });
+      test9("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);
+        expect9(count).toBe(7);
+        const sameHandle = client.counter.getOrCreate([
+          "test-get-or-create-handle"
+        ]);
+        const retrievedCount = await sameHandle.getCount();
+        expect9(retrievedCount).toBe(7);
+      });
+      test9("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);
+        expect9(count).toBe(9);
+        const retrievedCount = await handle.getCount();
+        expect9(retrievedCount).toBe(9);
+      });
+    });
+    describe10("Action Functionality", () => {
+      test9("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);
+        expect9(count1).toBe(3);
+        const count2 = await handle.increment(5);
+        expect9(count2).toBe(8);
+        const retrievedCount = await handle.getCount();
+        expect9(retrievedCount).toBe(8);
+      });
+      test9("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();
+        expect9(count).toBe(3);
+        const finalCount = await handle2.increment(4);
+        expect9(finalCount).toBe(7);
+        const checkCount = await handle1.getCount();
+        expect9(checkCount).toBe(7);
+      });
+      test9("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();
+        expect9(typeof actorId).toBe("string");
+        expect9(actorId).not.toBe("");
+        const idHandle = client.counter.getForId(actorId);
+        const count = await idHandle.getCount();
+        expect9(count).toBe(1);
+      });
+    });
+    describe10("Lifecycle Hooks", () => {
+      test9("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();
+        expect9(initialEvents).toContain("onStart");
+        const sameHandle = client.counterWithLifecycle.getOrCreate([
+          "test-lifecycle-handle"
+        ]);
+        const events = await sameHandle.getEvents();
+        expect9(events).toContain("onStart");
+        expect9(events.filter((e) => e === "onStart").length).toBe(1);
+      });
+      test9("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();
+        expect9(initialEvents).toContain("onStart");
+        expect9(initialEvents).not.toContain("onBeforeConnect");
+        expect9(initialEvents).not.toContain("onConnect");
+        expect9(initialEvents).not.toContain("onDisconnect");
+        const trackingHandle = client.counterWithLifecycle.getOrCreate(
+          ["test-lifecycle-action"],
+          { params: { trackLifecycle: true } }
+        );
+        await trackingHandle.increment(5);
+        const eventsAfterAction = await viewHandle.getEvents();
+        expect9(eventsAfterAction).toContain("onBeforeConnect");
+        expect9(eventsAfterAction).toContain("onConnect");
+        expect9(eventsAfterAction).toContain("onDisconnect");
+        expect9(
+          eventsAfterAction.filter((e) => e === "onBeforeConnect").length
+        ).toBe(1);
+        expect9(eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
+          1
+        );
+        expect9(
+          eventsAfterAction.filter((e) => e === "onDisconnect").length
+        ).toBe(1);
+        await trackingHandle.increment(10);
+        const eventsAfterSecondAction = await viewHandle.getEvents();
+        expect9(
+          eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length
+        ).toBe(2);
+        expect9(
+          eventsAfterSecondAction.filter((e) => e === "onConnect").length
+        ).toBe(2);
+        expect9(
+          eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
+        ).toBe(2);
+      });
+      test9("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();
+        expect9(events.filter((e) => e === "onStart").length).toBe(1);
+        expect9(events.filter((e) => e === "onBeforeConnect").length).toBe(2);
+        expect9(events.filter((e) => e === "onConnect").length).toBe(2);
+        expect9(events.filter((e) => e === "onDisconnect").length).toBe(2);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-inline-client.ts
+import { describe as describe11, expect as expect10, test as test10 } from "vitest";
+function runActorInlineClientTests(driverTestConfig) {
+  describe11("Actor Inline Client Tests", () => {
+    describe11("Stateless Client Calls", () => {
+      test10("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);
+        expect10(result).toBe(5);
+        const counterState = await inlineClientHandle.getCounterState();
+        expect10(counterState).toBe(5);
+        const messages = await inlineClientHandle.getMessages();
+        expect10(messages).toHaveLength(2);
+        expect10(messages[0]).toContain("Called counter.increment(5), result: 5");
+        expect10(messages[1]).toContain("Got counter state: 5");
+      });
+      test10("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();
+        expect10(result1).toBe(3);
+        expect10(result2).toBe(10);
+        expect10(finalState).toBe(10);
+        const messages = await inlineClientHandle.getMessages();
+        expect10(messages).toHaveLength(3);
+        expect10(messages[0]).toContain("Called counter.increment(3), result: 3");
+        expect10(messages[1]).toContain(
+          "Called counter.increment(7), result: 10"
+        );
+        expect10(messages[2]).toContain("Got counter state: 10");
+      });
+    });
+    describe11("Stateful Client Calls", () => {
+      test10("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);
+        expect10(result.result1).toBe(4);
+        expect10(result.result2).toBe(12);
+        expect10(result.events).toEqual([4, 12]);
+        const messages = await inlineClientHandle.getMessages();
+        expect10(messages).toHaveLength(1);
+        expect10(messages[0]).toContain(
+          "Connected to counter, incremented by 4 and 8"
+        );
+        expect10(messages[0]).toContain("results: 4, 12");
+        expect10(messages[0]).toContain("events: [4,12]");
+      });
+      test10("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);
+        expect10(result.result1).toBe(2);
+        expect10(result.result2).toBe(6);
+        expect10(result.events).toEqual([2, 6]);
+        const messages = await inlineClientHandle.getMessages();
+        expect10(messages).toHaveLength(1);
+        expect10(messages[0]).toContain(
+          "Connected to counter, incremented by 2 and 4"
+        );
+      });
+    });
+    describe11("Mixed Client Usage", () => {
+      test10("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();
+        expect10(statelessResult).toBe(1);
+        const statefulResult = await inlineClientHandle.connectToCounterAndIncrement(3);
+        expect10(statefulResult.result1).toBe(3);
+        expect10(statefulResult.result2).toBe(9);
+        const messages = await inlineClientHandle.getMessages();
+        expect10(messages).toHaveLength(3);
+        expect10(messages[0]).toContain("Called counter.increment(1), result: 1");
+        expect10(messages[1]).toContain("Got counter state: 1");
+        expect10(messages[2]).toContain(
+          "Connected to counter, incremented by 3 and 6"
+        );
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-inspector.ts
+import { describe as describe12, expect as expect11, test as test11 } from "vitest";
+function runActorInspectorTests(driverTestConfig) {
+  describe12("Actor Inspector Tests", () => {
+    describe12("Manager Inspector", () => {
+      test11("should respond to ping", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.ping.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual({ message: "pong" });
+      });
+      test11("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "1" }
+        });
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({ key: ["test-actor-1"] })
+          ])
+        );
+        expect11(data.length).toBe(1);
+      });
+      test11("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "5" }
+        });
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({
+              id: expect11.any(String),
+              key: actorKey1
+            }),
+            expect11.objectContaining({
+              id: expect11.any(String),
+              key: actorKey2
+            })
+          ])
+        );
+      });
+      test11("should handle invalid limit parameter", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$get({
+          query: { limit: "0" }
+        });
+        expect11(response.status).toBe(400);
+      });
+      test11("should create a new actor", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actors.$post({
+          json: {
+            name: "default",
+            key: ["test-create-actor"],
+            input: {}
+          }
+        });
+        expect11(response.status).toBe(201);
+        const data = await response.json();
+        expect11(data).toEqual(
+          expect11.objectContaining({
+            id: expect11.any(String),
+            name: "default",
+            key: ["test-create-actor"]
+          })
+        );
+      });
+      test11("should get builds", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.builds.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({ name: expect11.any(String) })
+          ])
+        );
+      });
+      test11("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actor[":id"].$get({
+          param: { id: actorId }
+        });
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toHaveProperty("id", actorId);
+      });
+      test11("should return 404 for non-existent actor", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const http = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.actor[":id"].$get({
+          param: { id: "non-existent-id" }
+        });
+        expect11(response.status).toBe(404);
+        const data = await response.json();
+        expect11(data).toEqual({ error: "Actor not found" });
+      });
+      test11("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 = createManagerInspectorClient(`${endpoint}/inspect`, {
+          headers: {
+            Authorization: `Bearer token`
+          }
+        });
+        const response = await http.bootstrap.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data.actors).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({
+              key: ["test-bootstrap"],
+              name: "counter"
+            })
+          ])
+        );
+      });
+    });
+    describe12("Actor Inspector", () => {
+      test11("should handle actor not found", async (c) => {
+        const { endpoint } = await setupDriverTest(c, driverTestConfig);
+        const actorId = "non-existing";
+        const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.ping.$get();
+        expect11(response.ok).toBe(false);
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.ping.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual({ message: "pong" });
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual({
+          enabled: true,
+          state: expect11.objectContaining({
+            count: 5
+          })
+        });
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$patch({
+          json: {
+            replace: { count: 10 }
+          }
+        });
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual({
+          enabled: true,
+          state: { count: 10 }
+        });
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.state.$patch({
+          json: {
+            patch: [
+              {
+                op: "replace",
+                path: "/count",
+                value: 7
+              }
+            ]
+          }
+        });
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual({
+          enabled: true,
+          state: expect11.objectContaining({
+            count: 7
+          })
+        });
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.connections.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data.connections).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({
+              id: expect11.any(String)
+            })
+          ])
+        );
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.events.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data.events).toEqual(
+          expect11.arrayContaining([
+            expect11.objectContaining({
+              type: "broadcast",
+              id: expect11.any(String)
+            })
+          ])
+        );
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        {
+          const response2 = await http.events.$get();
+          expect11(response2.status).toBe(200);
+          const data = await response2.json();
+          expect11(data.events).toEqual(
+            expect11.arrayContaining([
+              expect11.objectContaining({
+                type: "broadcast",
+                id: expect11.any(String)
+              })
+            ])
+          );
+        }
+        const response = await http.events.clear.$post();
+        expect11(response.status).toBe(200);
+      });
+      test11("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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.rpcs.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toEqual(
+          expect11.objectContaining({
+            rpcs: expect11.arrayContaining(["increment", "getCount"])
+          })
+        );
+      });
+      test11.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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [HEADER_ACTOR_QUERY]: JSON.stringify({
+              getForId: { name: "counter", actorId }
+            })
+          }
+        });
+        const response = await http.db.$get();
+        expect11(response.status).toBe(200);
+        const data = await response.json();
+        expect11(data).toHaveProperty("enabled");
+        expect11(typeof data.enabled).toBe("boolean");
+        if (data.enabled) {
+          expect11(data).toHaveProperty("db");
+          expect11(Array.isArray(data.db)).toBe(true);
+        } else {
+          expect11(data.db).toBe(null);
+        }
+      });
+      test11.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 = createActorInspectorClient(`${endpoint}/actors/inspect`, {
+          headers: {
+            Authorization: `Bearer token`,
+            [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: []
+            }
+          });
+          expect11(queryResponse.status).toBe(200);
+          const queryData = await queryResponse.json();
+          expect11(queryData).toHaveProperty("result");
+        } else {
+          const queryResponse = await http.db.$post({
+            json: {
+              query: "SELECT 1 as test",
+              params: []
+            }
+          });
+          expect11(queryResponse.status).toBe(200);
+          const queryData = await queryResponse.json();
+          expect11(queryData).toEqual({ enabled: false });
+        }
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-metadata.ts
+import { describe as describe13, expect as expect12, test as test12 } from "vitest";
+function runActorMetadataTests(driverTestConfig) {
+  describe13("Actor Metadata Tests", () => {
+    describe13("Actor Name", () => {
+      test12("should provide access to actor name", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.metadataActor.getOrCreate();
+        const actorName = await handle.getActorName();
+        expect12(actorName).toBe("metadataActor");
+      });
+      test12("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();
+        expect12(storedName).toBe("metadataActor");
+      });
+    });
+    describe13("Actor Tags", () => {
+      test12("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();
+        expect12(tags).toHaveProperty("env");
+        expect12(tags.env).toBe("test");
+        expect12(tags).toHaveProperty("purpose");
+        expect12(tags.purpose).toBe("metadata-test");
+      });
+      test12("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");
+        expect12(category).toBe("test-actor");
+        expect12(version).toBe("1.0");
+        expect12(nonexistent).toBeNull();
+      });
+    });
+    describe13("Metadata Structure", () => {
+      test12("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();
+        expect12(metadata).toHaveProperty("name");
+        expect12(metadata.name).toBe("metadataActor");
+        expect12(metadata).toHaveProperty("tags");
+        expect12(metadata.tags).toHaveProperty("type");
+        expect12(metadata.tags.type).toBe("metadata-test");
+        expect12(metadata).toHaveProperty("region");
+        expect12(metadata.region).toBe("us-west-1");
+      });
+    });
+    describe13("Region Information", () => {
+      test12("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();
+        expect12(region).toBe("eu-central-1");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-onstatechange.ts
+import { describe as describe14, expect as expect13, test as test13 } from "vitest";
+function runActorOnStateChangeTests(driverTestConfig) {
+  describe14("Actor onStateChange Tests", () => {
+    test13("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();
+      expect13(changeCount).toBe(1);
+    });
+    test13("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();
+      expect13(changeCount).toBe(3);
+    });
+    test13("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();
+      expect13(value).toBe(5);
+      const changeCount = await actor2.getChangeCount();
+      expect13(changeCount).toBe(1);
+    });
+    test13("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();
+        expect13(changeCount).toBe(1);
+      }
+      const doubled = await actor2.getDoubled();
+      expect13(doubled).toBe(6);
+      {
+        const changeCount = await actor2.getChangeCount();
+        expect13(changeCount).toBe(1);
+      }
+    });
+    test13("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();
+      expect13(value).toBe(0);
+      await connection.dispose();
+      const changeCount = await actor2.getChangeCount();
+      expect13(changeCount).toBe(0);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/actor-vars.ts
+import { describe as describe15, expect as expect14, test as test14 } from "vitest";
+function runActorVarsTests(driverTestConfig) {
+  describe15("Actor Variables", () => {
+    describe15("Static vars", () => {
+      test14("should provide access to static vars", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.staticVarActor.getOrCreate();
+        const result = await instance.getVars();
+        expect14(result).toEqual({ counter: 42, name: "test-actor" });
+        const name = await instance.getName();
+        expect14(name).toBe("test-actor");
+      });
+    });
+    describe15("Deep cloning of static vars", () => {
+      test14("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();
+        expect14(modifiedVars.nested.value).toBe("modified");
+        expect14(modifiedVars.nested.array).toContain(4);
+        expect14(modifiedVars.nested.obj.key).toBe("new-value");
+        const instance2Vars = await instance2.getVars();
+        expect14(instance2Vars.nested.value).toBe("original");
+        expect14(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect14(instance2Vars.nested.obj.key).toBe("value");
+      });
+    });
+    describe15("createVars", () => {
+      test14("should support dynamic vars creation", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.dynamicVarActor.getOrCreate();
+        const vars = await instance.getVars();
+        expect14(vars).toHaveProperty("random");
+        expect14(vars).toHaveProperty("computed");
+        expect14(typeof vars.random).toBe("number");
+        expect14(typeof vars.computed).toBe("string");
+        expect14(vars.computed).toMatch(/^Actor-\d+$/);
+      });
+      test14("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();
+        expect14(vars1.id).not.toBe(vars2.id);
+      });
+    });
+    describe15("Driver Context", () => {
+      test14("should provide access to driver context", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.driverCtxActor.getOrCreate();
+        const vars = await instance.getVars();
+        expect14(vars).toHaveProperty("hasDriverCtx");
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/manager-driver.ts
+import { describe as describe16, expect as expect15, test as test15 } from "vitest";
+function runManagerDriverTests(driverTestConfig) {
+  describe16("Manager Driver Tests", () => {
+    describe16("Client Connection Methods", () => {
+      test15("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);
+        expect15(count).toBe(5);
+        const counterB = client.counter.getOrCreate(["counter-b", "testing"]);
+        await counterB.increment(10);
+        const countB = await counterB.increment(0);
+        expect15(countB).toBe(10);
+      });
+      test15("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);
+          expect15.fail("did not error on duplicate create");
+        } catch (err) {
+          expect15(err.code).toBe("actor_already_exists");
+        }
+        const count = await counter.increment(0);
+        expect15(count).toBe(5);
+      });
+    });
+    describe16("Connection Options", () => {
+      test15("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();
+          expect15.fail("did not error for get");
+        } catch (err) {
+          expect15(err.code).toBe("actor_not_found");
+        }
+        const createdCounter = client.counter.getOrCreate(nonexistentId);
+        await createdCounter.increment(3);
+        const retrievedCounter = client.counter.get(nonexistentId);
+        const count = await retrievedCounter.increment(0);
+        expect15(count).toBe(3);
+      });
+      test15("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);
+        expect15(count).toBe(1);
+      });
+    });
+    describe16("Actor Creation & Retrieval", () => {
+      test15("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);
+        expect15(count).toBe(10);
+      });
+      test15("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();
+        expect15(inputs.initialInput).toEqual(testInput);
+        expect15(inputs.onCreateInput).toEqual(testInput);
+      });
+      test15("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();
+        expect15(inputs.initialInput).toBeUndefined();
+        expect15(inputs.onCreateInput).toBeUndefined();
+      });
+      test15("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();
+        expect15(inputs.initialInput).toEqual(testInput);
+        expect15(inputs.onCreateInput).toEqual(testInput);
+        const existingActor = client.inputActor.getOrCreate(uniqueKey);
+        const existingInputs = await existingActor.getInputs();
+        expect15(existingInputs.initialInput).toEqual(testInput);
+        expect15(existingInputs.onCreateInput).toEqual(testInput);
+      });
+    });
+    describe16("Key Matching", () => {
+      test15("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);
+        expect15(exactMatchCount).toBe(10);
+        const subsetMatchCounter = client.counter.getOrCreate([
+          "counter-match",
+          "test"
+        ]);
+        const subsetMatchCount = await subsetMatchCounter.increment(0);
+        expect15(subsetMatchCount).toBe(0);
+        const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
+        const singleKeyCount = await singleKeyCounter.increment(0);
+        expect15(singleKeyCount).toBe(0);
+      });
+      test15("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);
+        expect15(count).toBe(7);
+      });
+      test15("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);
+        expect15(emptyArrayCount).toBe(12);
+        const noKeyCounter = client.counter.getOrCreate();
+        const noKeyCount = await noKeyCounter.increment(0);
+        expect15(noKeyCount).toBe(12);
+      });
+      test15("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);
+        expect15(count).toBe(10);
+      });
+      test15("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);
+        expect15(keyedCount).toBe(0);
+      });
+    });
+    describe16("Multiple Actor Instances", () => {
+      test15("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"]);
+        expect15(await retrieved1.increment(0)).toBe(1);
+        expect15(await retrieved2.increment(0)).toBe(2);
+        expect15(await retrieved3.increment(0)).toBe(3);
+      });
+      test15("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);
+        expect15(count).toBe(5);
+      });
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-http.ts
+import { describe as describe17, expect as expect16, test as test16 } from "vitest";
+function runRawHttpTests(driverTestConfig) {
+  describe17("raw http", () => {
+    test16("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");
+      expect16(helloResponse.ok).toBe(true);
+      const helloData = await helloResponse.json();
+      expect16(helloData).toEqual({ message: "Hello from actor!" });
+    });
+    test16("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)
+      });
+      expect16(echoResponse.ok).toBe(true);
+      const echoData = await echoResponse.json();
+      expect16(echoData).toEqual(testData);
+    });
+    test16("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");
+      expect16(stateResponse.ok).toBe(true);
+      const stateData = await stateResponse.json();
+      expect16(stateData.requestCount).toBe(4);
+    });
+    test16("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
+      });
+      expect16(response.ok).toBe(true);
+      const headers = await response.json();
+      expect16(headers["x-custom-header"]).toBe("test-value");
+      expect16(headers["x-another-header"]).toBe("another-value");
+    });
+    test16("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");
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(404);
+    });
+    test16("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");
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(404);
+    });
+    test16("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");
+      expect16(response.ok).toBe(false);
+      expect16(response.status).toBe(500);
+      try {
+        const errorData = await response.json();
+        expect16(errorData.message).toContain(
+          "onFetch handler must return a Response"
+        );
+      } catch {
+      }
+    });
+    test16("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") {
+          expect16(response.ok).toBe(true);
+          const data = await response.json();
+          expect16(data).toEqual({ method });
+        } else if (method === "GET") {
+          expect16(response.status).toBe(404);
+        } else {
+          expect16(response.status).toBe(404);
+        }
+      }
+    });
+    test16("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
+      });
+      expect16(response.ok).toBe(true);
+      const responseBuffer = await response.arrayBuffer();
+      const responseArray = new Uint8Array(responseBuffer);
+      expect16(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+    });
+    test16("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("/");
+      expect16(rootResponse.ok).toBe(true);
+      const rootData = await rootResponse.json();
+      expect16(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      const usersResponse = await actor2.fetch("/users");
+      expect16(usersResponse.ok).toBe(true);
+      const users = await usersResponse.json();
+      expect16(users).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+      const userResponse = await actor2.fetch("/users/1");
+      expect16(userResponse.ok).toBe(true);
+      const user = await userResponse.json();
+      expect16(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)
+      });
+      expect16(createResponse.ok).toBe(true);
+      expect16(createResponse.status).toBe(201);
+      const createdUser = await createResponse.json();
+      expect16(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)
+      });
+      expect16(updateResponse.ok).toBe(true);
+      const updatedUser = await updateResponse.json();
+      expect16(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      const deleteResponse = await actor2.fetch("/users/2", {
+        method: "DELETE"
+      });
+      expect16(deleteResponse.ok).toBe(true);
+      const deleteResult = await deleteResponse.json();
+      expect16(deleteResult).toEqual({ message: "User 2 deleted" });
+      const notFoundResponse = await actor2.fetch("/api/unknown");
+      expect16(notFoundResponse.ok).toBe(false);
+      expect16(notFoundResponse.status).toBe(404);
+    });
+    test16("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");
+      expect16(responseWithoutSlash.ok).toBe(true);
+      const dataWithoutSlash = await responseWithoutSlash.json();
+      expect16(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      const responseWithSlash = await actor2.fetch("/api/hello");
+      expect16(responseWithSlash.ok).toBe(true);
+      const dataWithSlash = await responseWithSlash.json();
+      expect16(dataWithSlash).toEqual({ message: "Hello from actor!" });
+    });
+    test16("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");
+      expect16(response.ok).toBe(true);
+      const data = await response.json();
+      expect16(data).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+    });
+    test16("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);
+      expect16(response.ok).toBe(true);
+      const users = await response.json();
+      expect16(users).toEqual([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]);
+    });
+    test16("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);
+      expect16(response.ok).toBe(true);
+      const user = await response.json();
+      expect16(user).toEqual({ id: 1, name: "Alice" });
+    });
+    test16("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" })
+      });
+      expect16(urlResponse.ok).toBe(true);
+      const urlData = await urlResponse.json();
+      expect16(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);
+      expect16(requestResponse.ok).toBe(true);
+      const requestData = await requestResponse.json();
+      expect16(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" }
+      });
+      expect16(overrideResponse.ok).toBe(true);
+      const headers = await overrideResponse.json();
+      expect16(headers["x-override"]).toBe("init-header");
+      expect16(headers["x-original"]).toBe("request-header");
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-http-direct-registry.ts
+import { describe as describe18, expect as expect17, test as test17 } from "vitest";
+function runRawHttpDirectRegistryTests(driverTestConfig) {
+  describe18("raw http - direct registry access", () => {
+    test17("should handle direct fetch requests to registry with proper headers", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-test"]
+        }
+      };
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/hello`,
+        {
+          method: "GET",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery)
+          }
+        }
+      );
+      expect17(response.ok).toBe(true);
+      expect17(response.status).toBe(200);
+      const data = await response.json();
+      expect17(data).toEqual({ message: "Hello from actor!" });
+    });
+    test17("should handle POST requests with body to registry", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-post-test"]
+        }
+      };
+      const testData = { test: "direct", number: 456 };
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/echo`,
+        {
+          method: "POST",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(testData)
+        }
+      );
+      expect17(response.ok).toBe(true);
+      expect17(response.status).toBe(200);
+      const data = await response.json();
+      expect17(data).toEqual(testData);
+    });
+    test17("should pass custom headers through to actor", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-headers-test"]
+        }
+      };
+      const customHeaders = {
+        "X-Custom-Header": "direct-test-value",
+        "X-Another-Header": "another-direct-value"
+      };
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/headers`,
+        {
+          method: "GET",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+            ...customHeaders
+          }
+        }
+      );
+      expect17(response.ok).toBe(true);
+      const headers = await response.json();
+      expect17(headers["x-custom-header"]).toBe("direct-test-value");
+      expect17(headers["x-another-header"]).toBe("another-direct-value");
+    });
+    test17("should handle connection parameters for authentication", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-auth-test"]
+        }
+      };
+      const connParams = { token: "test-auth-token", userId: "user123" };
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/hello`,
+        {
+          method: "GET",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+            [HEADER_CONN_PARAMS]: JSON.stringify(connParams)
+          }
+        }
+      );
+      expect17(response.ok).toBe(true);
+      const data = await response.json();
+      expect17(data).toEqual({ message: "Hello from actor!" });
+    });
+    test17("should return 404 for actors without onFetch handler", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpNoHandlerActor",
+          key: ["direct-no-handler"]
+        }
+      };
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/anything`,
+        {
+          method: "GET",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery)
+          }
+        }
+      );
+      expect17(response.ok).toBe(false);
+      expect17(response.status).toBe(404);
+    });
+    test17("should handle different HTTP methods", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-methods-test"]
+        }
+      };
+      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+      for (const method of methods) {
+        const response = await fetch(
+          `${endpoint}/registry/actors/raw/http/api/echo`,
+          {
+            method,
+            headers: {
+              [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+              ...method !== "GET" ? { "Content-Type": "application/json" } : {}
+            },
+            body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
+          }
+        );
+        if (method === "POST") {
+          expect17(response.ok).toBe(true);
+          const data = await response.json();
+          expect17(data).toEqual({ method });
+        } else {
+          expect17(response.status).toBe(404);
+        }
+      }
+    });
+    test17("should handle binary data", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawHttpActor",
+          key: ["direct-binary-test"]
+        }
+      };
+      const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+      const response = await fetch(
+        `${endpoint}/registry/actors/raw/http/api/echo`,
+        {
+          method: "POST",
+          headers: {
+            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
+            "Content-Type": "application/octet-stream"
+          },
+          body: binaryData
+        }
+      );
+      expect17(response.ok).toBe(true);
+      const responseBuffer = await response.arrayBuffer();
+      const responseArray = new Uint8Array(responseBuffer);
+      expect17(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-http-request-properties.ts
+import { describe as describe19, expect as expect18, test as test18 } from "vitest";
+function runRawHttpRequestPropertiesTests(driverTestConfig) {
+  describe19("raw http request properties", () => {
+    test18("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" })
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.url).toContain("/test/path?foo=bar&baz=qux");
+      expect18(data.pathname).toBe("/test/path");
+      expect18(data.search).toBe("?foo=bar&baz=qux");
+      expect18(data.searchParams).toEqual({
+        foo: "bar",
+        baz: "qux"
+      });
+      expect18(data.method).toBe("POST");
+      expect18(data.headers["content-type"]).toBe("application/json");
+      expect18(data.headers["x-custom-header"]).toBe("custom-value");
+      expect18(data.headers["authorization"]).toBe("Bearer test-token");
+      expect18(data.body).toEqual({ test: "data" });
+    });
+    test18("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"
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.method).toBe("GET");
+      expect18(data.body).toBeNull();
+    });
+    test18("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()
+      });
+      expect18(formResponse.ok).toBe(true);
+      const formResult = await formResponse.json();
+      expect18(formResult.headers["content-type"]).toBe(
+        "application/x-www-form-urlencoded"
+      );
+      expect18(formResult.bodyText).toBe("field1=value1&field2=value2");
+      const textResponse = await actor2.fetch("test/text", {
+        method: "POST",
+        headers: {
+          "Content-Type": "text/plain"
+        },
+        body: "Hello, World!"
+      });
+      expect18(textResponse.ok).toBe(true);
+      const textResult = await textResponse.json();
+      expect18(textResult.headers["content-type"]).toBe("text/plain");
+      expect18(textResult.bodyText).toBe("Hello, World!");
+    });
+    test18("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"
+        }
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.headers["accept"]).toBe("application/json");
+      expect18(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
+      expect18(data.headers["cache-control"]).toBe("no-cache");
+      expect18(data.headers["user-agent"]).toBeTruthy();
+      expect18(data.headers["x-request-id"]).toBe("12345");
+    });
+    test18("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("");
+      expect18(rootResponse.ok).toBe(true);
+      const rootData = await rootResponse.json();
+      expect18(rootData.pathname).toBe("/");
+      const specialResponse = await actor2.fetch(
+        "test/path%20with%20spaces/and%2Fslashes"
+      );
+      expect18(specialResponse.ok).toBe(true);
+      const specialData = await specialResponse.json();
+      expect18(specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
+      const fragmentResponse = await actor2.fetch("test/path#fragment");
+      expect18(fragmentResponse.ok).toBe(true);
+      const fragmentData = await fragmentResponse.json();
+      expect18(fragmentData.pathname).toBe("/test/path");
+      expect18(fragmentData.hash).toBe("");
+    });
+    test18("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") {
+          expect18(response.status).toBe(200);
+          const text = await response.text();
+          expect18(text).toBe("");
+        } else if (method === "OPTIONS") {
+          expect18(response.status).toBe(204);
+          const text = await response.text();
+          expect18(text).toBe("");
+        } else {
+          expect18(response.ok).toBe(true);
+          const data = await response.json();
+          expect18(data.method).toBe(method);
+        }
+      }
+    });
+    test18("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"
+      );
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.searchParams.key).toBe("value2");
+      expect18(data.searchParams["array[]"]).toBe("2");
+      expect18(data.searchParams["nested[prop]"]).toBe("val");
+    });
+    test18("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
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.headers["content-type"]).toContain("multipart/form-data");
+      expect18(data.bodyText).toContain("field1");
+      expect18(data.bodyText).toContain("value1");
+    });
+    test18("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}`);
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.searchParams.param).toBe(longValue);
+      expect18(data.search.length).toBeGreaterThan(1e3);
+    });
+    test18("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)
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.body).toHaveLength(1e4);
+    });
+    test18("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"
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.bodyText).toBe("plain text without content-type");
+    });
+    test18("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: ""
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.body).toBeNull();
+      expect18(data.bodyText).toBe("");
+    });
+    test18("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();
+          expect18(data.method).toBe("CUSTOM");
+        }
+      } catch (error) {
+      }
+    });
+    test18("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"
+        }
+      });
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.headers.cookie).toBe(
+        "session=abc123; user=test; preferences=dark_mode"
+      );
+    });
+    test18("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"
+      );
+      expect18(response.ok).toBe(true);
+      const data = await response.json();
+      expect18(data.searchParams.special).toBe(" !@#$%^&");
+      expect18(data.searchParams.unicode).toBe("\u2713");
+      expect18(data.searchParams.email).toBe("test@example.com");
+    });
+    test18("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())
+      );
+      expect18(results[0].searchParams.id).toBe("1");
+      expect18(results[0].method).toBe("POST");
+      expect18(results[0].body).toEqual({ request: 1 });
+      expect18(results[1].searchParams.id).toBe("2");
+      expect18(results[1].method).toBe("PUT");
+      expect18(results[1].body).toEqual({ request: 2 });
+      expect18(results[2].searchParams.id).toBe("3");
+      expect18(results[2].method).toBe("DELETE");
+      expect18(results[2].body).toBeNull();
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-websocket.ts
+import { describe as describe20, expect as expect19, test as test19 } from "vitest";
+function runRawWebSocketTests(driverTestConfig) {
+  describe20("raw websocket", () => {
+    test19("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);
+      });
+      expect19(welcomeMessage.type).toBe("welcome");
+      expect19(welcomeMessage.connectionCount).toBe(1);
+      ws.close();
+    });
+    test19("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);
+      });
+      expect19(echoMessage).toEqual(testMessage);
+      ws.close();
+    });
+    test19("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);
+      });
+      expect19(pongMessage.type).toBe("pong");
+      expect19(pongMessage.timestamp).toBeDefined();
+      ws.close();
+    });
+    test19("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;
+      expect19(stats.connectionCount).toBe(2);
+      expect19(stats.messageCount).toBe(4);
+      const actionStats = await actor1.getStats();
+      expect19(actionStats.connectionCount).toBe(2);
+      expect19(actionStats.messageCount).toBe(4);
+      ws1.close();
+      ws2.close();
+    });
+    test19("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();
+      expect19(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++) {
+        expect19(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+      }
+      ws.close();
+    });
+    test19("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 }
+        );
+      });
+      expect19(welcomeMessage.type).toBe("welcome");
+      ws.close();
+    });
+    test19("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);
+      });
+      expect19(response).toBeDefined();
+      ws.close();
+    });
+    test19("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();
+      expect19(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));
+      }
+      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+    });
+    test19("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);
+      });
+      expect19(welcome1.type).toBe("welcome");
+      expect19(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);
+      });
+      expect19(welcome2.type).toBe("welcome");
+      expect19(welcome2.connectionCount).toBe(2);
+      const midStats = await actor2.getStats();
+      expect19(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));
+      }
+      expect19(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));
+      }
+      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+    });
+    test19("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;
+      expect19(requestInfo.url).toContain("api/v1/stream");
+      expect19(requestInfo.url).toContain("token=abc123");
+      expect19(requestInfo.url).toContain("user=test");
+      ws.close();
+    });
+  });
+}
+
+// src/driver-test-suite/tests/raw-websocket-direct-registry.ts
+import { describe as describe21, expect as expect20, test as test20 } from "vitest";
+function runRawWebSocketDirectRegistryTests(driverTestConfig) {
+  describe21("raw websocket - direct registry access", () => {
+    test20("should establish vanilla WebSocket connection with proper subprotocols", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-test"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("open", () => {
+          resolve2();
+        });
+        ws.addEventListener("error", reject);
+        ws.addEventListener("close", reject);
+      });
+      const welcomeMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      expect20(welcomeMessage.type).toBe("welcome");
+      expect20(welcomeMessage.connectionCount).toBe(1);
+      ws.close();
+    });
+    test20("should echo messages with vanilla WebSocket", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-echo"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      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: "vanilla", 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);
+      });
+      expect20(echoMessage).toEqual(testMessage);
+      ws.close();
+    });
+    test20("should handle connection parameters for authentication", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-auth"]
+        }
+      };
+      const connParams = { token: "ws-auth-token", userId: "ws-user123" };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const connParamsProtocol = `conn_params.${encodeURIComponent(JSON.stringify(connParams))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        connParamsProtocol,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("open", () => {
+          resolve2();
+        });
+        ws.addEventListener("error", reject);
+        ws.addEventListener("close", reject);
+      });
+      const welcomeMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      expect20(welcomeMessage.type).toBe("welcome");
+      ws.close();
+    });
+    test20("should handle custom user protocols alongside rivetkit protocols", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-protocols"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const userProtocol1 = "chat-v1";
+      const userProtocol2 = "custom-protocol";
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        userProtocol1,
+        userProtocol2,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("open", () => {
+          resolve2();
+        });
+        ws.addEventListener("error", reject);
+        ws.addEventListener("close", reject);
+      });
+      const welcomeMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      expect20(welcomeMessage.type).toBe("welcome");
+      ws.close();
+    });
+    test20("should handle different paths for WebSocket routes", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-paths"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const paths = ["chat/room1", "updates/feed", "stream/events"];
+      for (const path of paths) {
+        const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/${path}`;
+        const ws = new WebSocket2(wsUrl, [
+          queryProtocol,
+          // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+          "rivetkit"
+        ]);
+        await new Promise((resolve2, reject) => {
+          ws.addEventListener("open", () => {
+            resolve2();
+          });
+          ws.addEventListener("error", reject);
+        });
+        const welcomeMessage = await new Promise((resolve2, reject) => {
+          ws.addEventListener(
+            "message",
+            (event) => {
+              resolve2(JSON.parse(event.data));
+            },
+            { once: true }
+          );
+          ws.addEventListener("close", reject);
+        });
+        expect20(welcomeMessage.type).toBe("welcome");
+        ws.close();
+      }
+    });
+    test20("should return error for actors without onWebSocket handler", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketNoHandlerActor",
+          key: ["vanilla-no-handler"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      await new Promise((resolve2) => {
+        ws.addEventListener("error", () => resolve2(), { once: true });
+        ws.addEventListener("close", () => resolve2(), { once: true });
+      });
+      expect20(ws.readyState).toBe(ws.CLOSED || 3);
+    });
+    test20("should handle binary data over vanilla WebSocket", async (c) => {
+      const { endpoint } = await setupDriverTest(c, driverTestConfig);
+      const WebSocket2 = await importWebSocket();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "rawWebSocketActor",
+          key: ["vanilla-binary"]
+        }
+      };
+      const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+      const wsEndpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+      const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+      const ws = new WebSocket2(wsUrl, [
+        queryProtocol,
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      ws.binaryType = "arraybuffer";
+      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 binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+      ws.send(binaryData.buffer);
+      const echoedData = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(event.data);
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      const echoedArray = new Uint8Array(echoedData);
+      expect20(Array.from(echoedArray)).toEqual([1, 2, 3, 4, 5]);
+      ws.send(JSON.stringify({ type: "binary-test", size: binaryData.length }));
+      const echoMessage = await new Promise((resolve2, reject) => {
+        ws.addEventListener(
+          "message",
+          (event) => {
+            resolve2(JSON.parse(event.data));
+          },
+          { once: true }
+        );
+        ws.addEventListener("close", reject);
+      });
+      expect20(echoMessage.type).toBe("binary-test");
+      expect20(echoMessage.size).toBe(5);
+      ws.close();
+    });
+  });
+}
+
+// src/driver-test-suite/tests/request-access.ts
+import { describe as describe22, expect as expect21, test as test21 } from "vitest";
+function runRequestAccessTests(driverTestConfig) {
+  describe22("Request Access in Lifecycle Hooks", () => {
+    test21("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") {
+        expect21(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect21(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect21(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect21(requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
+        expect21(requestInfo.createConnState.hasRequest).toBe(true);
+        expect21(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect21(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect21(requestInfo.createConnState.requestHeaders).toBeDefined();
+      } else {
+      }
+      await connection.dispose();
+    });
+    test21("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();
+      expect21(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect21(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect21(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect21(
+        Object.keys(requestInfo.onBeforeConnect.requestHeaders)
+      ).toHaveLength(0);
+      expect21(requestInfo.createConnState.hasRequest).toBe(false);
+      expect21(requestInfo.createConnState.requestUrl).toBeNull();
+      expect21(requestInfo.createConnState.requestMethod).toBeNull();
+      expect21(
+        Object.keys(requestInfo.createConnState.requestHeaders)
+      ).toHaveLength(0);
+      await connection.dispose();
+    });
+    test21("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") {
+        expect21(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect21(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
+        expect21(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
+        expect21(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
+        expect21(typeof requestInfo.onBeforeConnect.requestHeaders).toBe(
+          "object"
+        );
+        expect21(requestInfo.createConnState.hasRequest).toBe(true);
+        expect21(requestInfo.createConnState.requestMethod).toBeTruthy();
+        expect21(requestInfo.createConnState.requestUrl).toBeTruthy();
+        expect21(requestInfo.createConnState.requestHeaders).toBeTruthy();
+        expect21(typeof requestInfo.createConnState.requestHeaders).toBe(
+          "object"
+        );
+      } else {
+      }
+      await connection.dispose();
+    });
+    test21("should have access to request object in onAuth", async (c) => {
+      const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+      if (driverTestConfig.clientType === "http") {
+        console.log("Skipping onAuth test - requires public endpoint setup");
+      }
+    });
+    test21("should have access to request object in onFetch", async (c) => {
+      const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+      const handle = client.requestAccessActor.getOrCreate(["test-fetch"]);
+      await handle.resolve();
+      const actorQuery = {
+        getOrCreateForKey: {
+          name: "requestAccessActor",
+          key: ["test-fetch"]
+        }
+      };
+      const url = `${endpoint}/registry/actors/raw/http/test-path`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Test-Header": "test-value",
+          "X-RivetKit-Query": JSON.stringify(actorQuery)
+        },
+        body: JSON.stringify({ test: "data" })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(
+          `HTTP request failed: ${response.status} ${response.statusText}`,
+          errorText
+        );
+      }
+      expect21(response.ok).toBe(true);
+      const data = await response.json();
+      expect21(data.hasRequest).toBe(true);
+      expect21(data.requestUrl).toContain("/test-path");
+      expect21(data.requestMethod).toBe("POST");
+      expect21(data.requestHeaders).toBeDefined();
+      expect21(data.requestHeaders["content-type"]).toBe(
+        "application/json"
+      );
+      expect21(data.requestHeaders["x-test-header"]).toBe("test-value");
+    });
+    test21("should have access to request object in onWebSocket", async (c) => {
+      const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
+      if (typeof WebSocket !== "undefined") {
+        const handle = client.requestAccessActor.getOrCreate([
+          "test-websocket"
+        ]);
+        await handle.resolve();
+        const actorQuery = {
+          getOrCreateForKey: {
+            name: "requestAccessActor",
+            key: ["test-websocket"]
+          }
+        };
+        const queryProtocol = `query.${encodeURIComponent(JSON.stringify(actorQuery))}`;
+        const wsUrl = endpoint.replace("http://", "ws://").replace("https://", "wss://");
+        const ws = new WebSocket(
+          `${wsUrl}/registry/actors/raw/websocket/test-path`,
+          [
+            queryProtocol,
+            "rivetkit"
+            // Required protocol
+          ]
+        );
+        await new Promise((resolve2, reject) => {
+          ws.onopen = () => {
+          };
+          ws.onmessage = (event) => {
+            try {
+              const data = JSON.parse(event.data);
+              expect21(data.hasRequest).toBe(true);
+              expect21(data.requestUrl).toContain("/test-path");
+              expect21(data.requestMethod).toBe("GET");
+              expect21(data.requestHeaders).toBeDefined();
+              ws.close();
+              resolve2();
+            } catch (error) {
+              reject(error);
+            }
+          };
+          ws.onerror = (error) => {
+            reject(error);
+          };
+        });
+      }
+    });
+  });
+}
+
+// src/driver-test-suite/mod.ts
+function runDriverTests(driverTestConfigPartial) {
+  for (const clientType of ["http", "inline"]) {
+    const driverTestConfig = {
+      ...driverTestConfigPartial,
+      clientType
+    };
+    describe23(`client type (${clientType})`, () => {
+      runActorDriverTests(driverTestConfig);
+      runManagerDriverTests(driverTestConfig);
+      for (const transport of ["websocket", "sse"]) {
+        describe23(`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);
+      runActorAuthTests(driverTestConfig);
+      runActorInlineClientTests(driverTestConfig);
+      runRawHttpTests(driverTestConfig);
+      runRawHttpRequestPropertiesTests(driverTestConfig);
+      runRawWebSocketTests(driverTestConfig);
+      runRawHttpDirectRegistryTests(driverTestConfig);
+      runRawWebSocketDirectRegistryTests(driverTestConfig);
+      runActorInspectorTests(driverTestConfig);
+    });
+  }
+}
+async function createTestRuntime(registryPath, driverFactory) {
+  const {
+    mod: { registry }
+  } = await bundleRequire({
+    filepath: registryPath
+  });
+  registry.config.test.enabled = true;
+  const { driver, cleanup: driverCleanup } = await driverFactory(registry);
+  let injectWebSocket;
+  let upgradeWebSocket;
+  const config = RunConfigSchema.parse({
+    driver,
+    getUpgradeWebSocket: () => upgradeWebSocket,
+    inspector: {
+      enabled: true,
+      token: () => "token"
+    }
+  });
+  const managerDriver = driver.manager(registry.config, config);
+  const inlineDriver = createInlineClientDriver(managerDriver);
+  const { router } = createManagerRouter(
+    registry.config,
+    config,
+    inlineDriver,
+    managerDriver,
+    false
+  );
+  const nodeWebSocket = createNodeWebSocket({ app: router });
+  upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+  injectWebSocket = nodeWebSocket.injectWebSocket;
+  const port = await getPort();
+  const server = honoServe({
+    fetch: router.fetch,
+    hostname: "127.0.0.1",
+    port
+  });
+  invariant(injectWebSocket !== void 0, "should have injectWebSocket");
+  injectWebSocket(server);
+  const endpoint = `http://127.0.0.1:${port}`;
+  const cleanup = async () => {
+    await new Promise((resolve2) => server.close(() => resolve2(void 0)));
+    await (driverCleanup == null ? void 0 : driverCleanup());
+  };
+  return {
+    endpoint,
+    cleanup
+  };
+}
+export {
+  createTestRuntime,
+  runDriverTests
+};
+//# sourceMappingURL=mod.js.map