rivetkit 2.0.3 → 2.0.4

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

@@ -1,314 +1,52 @@
 import {
   getPort
-} from "../chunk-6PDXBYI5.js";
+} from "../chunk-3F2YSRJL.js";
+import {
+  createClient
+} from "../chunk-HI3HWJRC.js";
 import {
   actor,
-  createInlineClientDriver,
   createManagerRouter
-} from "../chunk-OV6AYD4S.js";
+} from "../chunk-XJQHKJ4P.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";
+} from "../chunk-H26RP6GD.js";
+import "../chunk-QK72M5JB.js";
 import {
   RunConfigSchema
-} from "../chunk-KJCJLKRM.js";
-import "../chunk-VRRHBNJC.js";
+} from "../chunk-TQ62L3X7.js";
 import {
   HEADER_ACTOR_QUERY,
-  HEADER_CONN_PARAMS,
-  HEADER_ENCODING,
   assertUnreachable
-} from "../chunk-4NSUQZ2H.js";
+} from "../chunk-HLLF4B4Q.js";
 import {
   getLogger
-} from "../chunk-XFSS33EQ.js";
-import "../chunk-3H7O2A7I.js";
+} from "../chunk-LV2S3OU3.js";
+import "../chunk-PQY7KKTL.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-INGJP237.js";
+} from "../chunk-NFU2BBT5.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";
+import { describe as describe20 } from "vitest";
 
 // src/driver-test-suite/log.ts
-var LOGGER_NAME = "test-suite";
 function logger() {
-  return getLogger(LOGGER_NAME);
+  return getLogger("test-suite");
 }
 
-// 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/tests/action-features.ts
+import { describe, expect, test } from "vitest";
 
 // src/driver-test-suite/utils.ts
+import { resolve } from "path";
+import { vi } from "vitest";
 var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
 async function setupDriverTest(c, driverTestConfig) {
   if (!driverTestConfig.useRealTimers) {
@@ -316,19 +54,18 @@ async function setupDriverTest(c, driverTestConfig) {
     vi.setSystemTime(FAKE_TIME);
   }
   const projectPath = resolve(__dirname, "../../fixtures/driver-test-suite");
-  const { endpoint, cleanup } = await driverTestConfig.start(projectPath);
+  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start(projectPath);
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = createClient(endpoint, {
+    client = createClient({
+      endpoint,
+      namespace,
+      runnerName,
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
-    const clientDriver = createTestInlineClientDriver(
-      endpoint,
-      driverTestConfig.transport ?? "websocket"
-    );
-    client = createClientWithDriver(clientDriver);
+    throw "TODO";
   } else {
     assertUnreachable(driverTestConfig.clientType);
   }
@@ -430,447 +167,21 @@ function runActionFeaturesTests(driverTestConfig) {
   });
 }
 
-// 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";
+import { describe as describe2, expect as expect2, test as test2 } from "vitest";
 function runActorConnTests(driverTestConfig) {
-  describe3("Actor Connection Tests", () => {
-    describe3("Connection Methods", () => {
-      test3("should connect using .get().connect()", async (c) => {
+  describe2("Actor Connection Tests", () => {
+    describe2("Connection Methods", () => {
+      test2("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);
+        expect2(count).toBe(5);
         await connection.dispose();
       });
-      test3("should connect using .getForId().connect()", async (c) => {
+      test2("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);
@@ -878,28 +189,28 @@ function runActorConnTests(driverTestConfig) {
         const idHandle = client.counter.getForId(actorId);
         const connection = idHandle.connect();
         const count = await connection.getCount();
-        expect3(count).toBe(3);
+        expect2(count).toBe(3);
         await connection.dispose();
       });
-      test3("should connect using .getOrCreate().connect()", async (c) => {
+      test2("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);
+        expect2(count).toBe(7);
         await connection.dispose();
       });
-      test3("should connect using (await create()).connect()", async (c) => {
+      test2("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);
+        expect2(count).toBe(9);
         await connection.dispose();
       });
     });
-    describe3("Event Communication", () => {
-      test3("should mix RPC calls and WebSocket events", async (c) => {
+    describe2("Event Communication", () => {
+      test2("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();
@@ -917,7 +228,7 @@ function runActorConnTests(driverTestConfig) {
         await receivedEventsPromise;
         await connection.dispose();
       });
-      test3("should receive events via broadcast", async (c) => {
+      test2("should receive events via broadcast", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-broadcast"]);
         const connection = handle.connect();
@@ -927,11 +238,11 @@ function runActorConnTests(driverTestConfig) {
         });
         await connection.increment(5);
         await connection.increment(3);
-        expect3(receivedEvents).toContain(5);
-        expect3(receivedEvents).toContain(8);
+        expect2(receivedEvents).toContain(5);
+        expect2(receivedEvents).toContain(8);
         await connection.dispose();
       });
-      test3("should handle one-time events with once()", async (c) => {
+      test2("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();
@@ -941,11 +252,11 @@ function runActorConnTests(driverTestConfig) {
         });
         await connection.increment(5);
         await connection.increment(3);
-        expect3(receivedEvents).toEqual([5]);
-        expect3(receivedEvents).not.toContain(8);
+        expect2(receivedEvents).toEqual([5]);
+        expect2(receivedEvents).not.toContain(8);
         await connection.dispose();
       });
-      test3("should unsubscribe from events", async (c) => {
+      test2("should unsubscribe from events", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.counter.getOrCreate(["test-unsubscribe"]);
         const connection = handle.connect();
@@ -956,13 +267,13 @@ function runActorConnTests(driverTestConfig) {
         await connection.increment(5);
         unsubscribe();
         await connection.increment(3);
-        expect3(receivedEvents).toEqual([5]);
-        expect3(receivedEvents).not.toContain(8);
+        expect2(receivedEvents).toEqual([5]);
+        expect2(receivedEvents).not.toContain(8);
         await connection.dispose();
       });
     });
-    describe3("Connection Parameters", () => {
-      test3("should pass connection parameters", async (c) => {
+    describe2("Connection Parameters", () => {
+      test2("should pass connection parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle1 = client.counterWithParams.getOrCreate(["test-params"], {
           params: { name: "user1" }
@@ -975,14 +286,14 @@ function runActorConnTests(driverTestConfig) {
         await conn1.getInitializers();
         await conn2.getInitializers();
         const initializers = await conn1.getInitializers();
-        expect3(initializers).toContain("user1");
-        expect3(initializers).toContain("user2");
+        expect2(initializers).toContain("user1");
+        expect2(initializers).toContain("user2");
         await conn1.dispose();
         await conn2.dispose();
       });
     });
-    describe3("Lifecycle Hooks", () => {
-      test3("should trigger lifecycle hooks", async (c) => {
+    describe2("Lifecycle Hooks", () => {
+      test2("should trigger lifecycle hooks", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connHandle = client.counterWithLifecycle.getOrCreate(
           ["test-lifecycle"],
@@ -992,13 +303,13 @@ function runActorConnTests(driverTestConfig) {
         );
         const connection = connHandle.connect();
         const events = await connection.getEvents();
-        expect3(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
+        expect2(events).toEqual(["onStart", "onBeforeConnect", "onConnect"]);
         await connection.dispose();
         const handle = client.counterWithLifecycle.getOrCreate([
           "test-lifecycle"
         ]);
         const finalEvents = await handle.getEvents();
-        expect3(finalEvents).toBeOneOf([
+        expect2(finalEvents).toBeOneOf([
           // Still active
           ["onStart", "onBeforeConnect", "onConnect", "onDisconnect"],
           // Went to sleep and woke back up
@@ -1012,8 +323,8 @@ function runActorConnTests(driverTestConfig) {
         ]);
       });
     });
-    describe3("Connection Liveness", () => {
-      test3.skip("should return correct liveness status for connections", async (c) => {
+    describe2("Connection Liveness", () => {
+      test2.skip("should return correct liveness status for connections", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connLivenessActor.getOrCreate([
           "test-liveness-status"
@@ -1025,18 +336,18 @@ function runActorConnTests(driverTestConfig) {
         await connA.increment(5);
         await connB.increment(5);
         const counter = await handle.getCounter();
-        expect3(counter).toBe(10);
+        expect2(counter).toBe(10);
         const connectionsStatusBeforeKill = await handle.getWsConnectionsLiveness();
-        expect3(connectionsStatusBeforeKill).toHaveLength(2);
-        expect3(connectionsStatusBeforeKill).toContainEqual(
-          expect3.objectContaining({
+        expect2(connectionsStatusBeforeKill).toHaveLength(2);
+        expect2(connectionsStatusBeforeKill).toContainEqual(
+          expect2.objectContaining({
             id: connAId,
             status: "connected",
             lastSeen: FAKE_TIME.getTime()
           })
         );
-        expect3(connectionsStatusBeforeKill).toContainEqual(
-          expect3.objectContaining({
+        expect2(connectionsStatusBeforeKill).toContainEqual(
+          expect2.objectContaining({
             id: connBId,
             status: "connected",
             lastSeen: FAKE_TIME.getTime()
@@ -1044,14 +355,14 @@ function runActorConnTests(driverTestConfig) {
         );
         await handle.kill(connAId);
         const connectionsStatusAfterKill = await handle.getWsConnectionsLiveness();
-        expect3(connectionsStatusAfterKill).toEqual(
-          expect3.arrayContaining([
-            expect3.objectContaining({
+        expect2(connectionsStatusAfterKill).toEqual(
+          expect2.arrayContaining([
+            expect2.objectContaining({
               id: connAId,
               status: "reconnecting",
               lastSeen: FAKE_TIME.getTime()
             }),
-            expect3.objectContaining({
+            expect2.objectContaining({
               id: connBId,
               status: "connected",
               lastSeen: FAKE_TIME.getTime()
@@ -1060,13 +371,13 @@ function runActorConnTests(driverTestConfig) {
         );
         await waitFor(driverTestConfig, 5e3);
         const connectionsStatusAfterCleanup = await handle.getWsConnectionsLiveness();
-        expect3(connectionsStatusAfterCleanup).not.toContainEqual(
-          expect3.objectContaining({
+        expect2(connectionsStatusAfterCleanup).not.toContainEqual(
+          expect2.objectContaining({
             id: connAId
           })
         );
-        expect3(connectionsStatusAfterCleanup).toContainEqual(
-          expect3.objectContaining({
+        expect2(connectionsStatusAfterCleanup).toContainEqual(
+          expect2.objectContaining({
             id: connBId
           })
         );
@@ -1076,22 +387,22 @@ function runActorConnTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-conn-state.ts
-import { describe as describe4, expect as expect4, test as test4, vi as vi2 } from "vitest";
+import { describe as describe3, expect as expect3, test as test3, vi as vi2 } from "vitest";
 function runActorConnStateTests(driverTestConfig) {
-  describe4("Actor Connection State Tests", () => {
-    describe4("Connection State Initialization", () => {
-      test4("should retrieve connection state", async (c) => {
+  describe3("Actor Connection State Tests", () => {
+    describe3("Connection State Initialization", () => {
+      test3("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();
+        expect3(connState.id).toBeDefined();
+        expect3(connState.username).toBeDefined();
+        expect3(connState.role).toBeDefined();
+        expect3(connState.counter).toBeDefined();
+        expect3(connState.createdAt).toBeDefined();
         await connection.dispose();
       });
-      test4("should initialize connection state with custom parameters", async (c) => {
+      test3("should initialize connection state with custom parameters", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const connection = client.connStateActor.getOrCreate([], {
           params: {
@@ -1100,13 +411,13 @@ function runActorConnStateTests(driverTestConfig) {
           }
         }).connect();
         const connState = await connection.getConnectionState();
-        expect4(connState.username).toBe("testuser");
-        expect4(connState.role).toBe("admin");
+        expect3(connState.username).toBe("testuser");
+        expect3(connState.role).toBe("admin");
         await connection.dispose();
       });
     });
-    describe4("Connection State Management", () => {
-      test4("should maintain unique state for each connection", async (c) => {
+    describe3("Connection State Management", () => {
+      test3("should maintain unique state for each connection", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const conn1 = client.connStateActor.getOrCreate([], {
           params: { username: "user1" }
@@ -1118,14 +429,14 @@ function runActorConnStateTests(driverTestConfig) {
         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");
+        expect3(state1.counter).toBe(5);
+        expect3(state2.counter).toBe(10);
+        expect3(state1.username).toBe("user1");
+        expect3(state2.username).toBe("user2");
         await conn1.dispose();
         await conn2.dispose();
       });
-      test4("should track connections in shared state", async (c) => {
+      test3("should track connections in shared state", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -1134,12 +445,12 @@ function runActorConnStateTests(driverTestConfig) {
         await conn2.getConnectionState();
         const state1 = await conn1.getConnectionState();
         const connectionIds = await conn1.getConnectionIds();
-        expect4(connectionIds.length).toBeGreaterThanOrEqual(2);
-        expect4(connectionIds).toContain(state1.id);
+        expect3(connectionIds.length).toBeGreaterThanOrEqual(2);
+        expect3(connectionIds).toContain(state1.id);
         await conn1.dispose();
         await conn2.dispose();
       });
-      test4("should identify different connections in the same actor", async (c) => {
+      test3("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();
@@ -1147,50 +458,50 @@ function runActorConnStateTests(driverTestConfig) {
         await conn1.getConnectionState();
         await conn2.getConnectionState();
         const allStates = await conn1.getAllConnectionStates();
-        expect4(allStates.length).toBeGreaterThanOrEqual(2);
+        expect3(allStates.length).toBeGreaterThanOrEqual(2);
         const ids = allStates.map((state) => state.id);
         const uniqueIds = [...new Set(ids)];
-        expect4(uniqueIds.length).toBe(ids.length);
+        expect3(uniqueIds.length).toBe(ids.length);
         await conn1.dispose();
         await conn2.dispose();
       });
     });
-    describe4("Connection Lifecycle", () => {
-      test4("should track connection and disconnection events", async (c) => {
+    describe3("Connection Lifecycle", () => {
+      test3("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);
+        expect3(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);
+          expect3(newDisconnections).toBeGreaterThan(initialDisconnections);
         });
         await newConn.dispose();
       });
-      test4("should update connection state", async (c) => {
+      test3("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");
+        expect3(initialState.username).toBe("anonymous");
         const updatedState = await conn.updateConnection({
           username: "newname",
           role: "moderator"
         });
-        expect4(updatedState.username).toBe("newname");
-        expect4(updatedState.role).toBe("moderator");
+        expect3(updatedState.username).toBe("newname");
+        expect3(updatedState.role).toBe("moderator");
         const latestState = await conn.getConnectionState();
-        expect4(latestState.username).toBe("newname");
-        expect4(latestState.role).toBe("moderator");
+        expect3(latestState.username).toBe("newname");
+        expect3(latestState.role).toBe("moderator");
         await conn.dispose();
       });
     });
-    describe4("Connection Communication", () => {
-      test4("should send messages to specific connections", async (c) => {
+    describe3("Connection Communication", () => {
+      test3("should send messages to specific connections", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.connStateActor.getOrCreate();
         const conn1 = handle.connect();
@@ -1205,10 +516,10 @@ function runActorConnStateTests(driverTestConfig) {
           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");
+        expect3(success).toBe(true);
+        expect3(receivedMessages.length).toBe(1);
+        expect3(receivedMessages[0].from).toBe(state1.id);
+        expect3(receivedMessages[0].message).toBe("Hello from conn1");
         await conn1.dispose();
         await conn2.dispose();
       });
@@ -1217,17 +528,17 @@ function runActorConnStateTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-driver.ts
-import { describe as describe8 } from "vitest";
+import { describe as describe7 } from "vitest";
 
 // src/driver-test-suite/tests/actor-schedule.ts
-import { describe as describe5, expect as expect5, test as test5 } from "vitest";
+import { describe as describe4, expect as expect4, test as test4 } from "vitest";
 function runActorScheduleTests(driverTestConfig) {
   var _a;
-  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.schedule)(
+  describe4.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) => {
+      describe4("Scheduled Alarms", () => {
+        test4("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;
@@ -1235,32 +546,32 @@ function runActorScheduleTests(driverTestConfig) {
           await waitFor(driverTestConfig, 200);
           const lastRun = await scheduled.getLastRun();
           const scheduledCount = await scheduled.getScheduledCount();
-          expect5(lastRun).toBeGreaterThan(0);
-          expect5(scheduledCount).toBe(1);
+          expect4(lastRun).toBeGreaterThan(0);
+          expect4(scheduledCount).toBe(1);
         });
-        test5("executes c.schedule.after() with delay", async (c) => {
+        test4("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);
+          expect4(lastRun).toBeGreaterThan(0);
+          expect4(scheduledCount).toBe(1);
         });
-        test5("scheduled tasks persist across actor restarts", async (c) => {
+        test4("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);
+          expect4(initialCount).toBe(0);
           await waitFor(driverTestConfig, 200);
           const scheduledCount = await newInstance.getScheduledCount();
-          expect5(scheduledCount).toBe(1);
+          expect4(scheduledCount).toBe(1);
         });
-        test5("multiple scheduled tasks execute in order", async (c) => {
+        test4("multiple scheduled tasks execute in order", async (c) => {
           const { client } = await setupDriverTest(c, driverTestConfig);
           const scheduled = client.scheduled.getOrCreate();
           await scheduled.clearHistory();
@@ -1269,13 +580,13 @@ function runActorScheduleTests(driverTestConfig) {
           await scheduled.scheduleTaskAfterWithId("third", 500);
           await waitFor(driverTestConfig, 200);
           const history1 = await scheduled.getTaskHistory();
-          expect5(history1).toEqual(["first"]);
+          expect4(history1).toEqual(["first"]);
           await waitFor(driverTestConfig, 200);
           const history2 = await scheduled.getTaskHistory();
-          expect5(history2).toEqual(["first", "second"]);
+          expect4(history2).toEqual(["first", "second"]);
           await waitFor(driverTestConfig, 200);
           const history3 = await scheduled.getTaskHistory();
-          expect5(history3).toEqual(["first", "second", "third"]);
+          expect4(history3).toEqual(["first", "second", "third"]);
         });
       });
     }
@@ -1283,13 +594,11 @@ function runActorScheduleTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-sleep.ts
-import { describe as describe6, expect as expect6, test as test6 } from "vitest";
+import { describe as describe5, expect as expect5, test as test5 } 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;
@@ -1316,8 +625,6 @@ var sleep = actor({
   }
 });
 var sleepWithLongRpc = actor({
-  onAuth: () => {
-  },
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -1347,8 +654,6 @@ var sleepWithLongRpc = actor({
   }
 });
 var sleepWithRawHttp = actor({
-  onAuth: () => {
-  },
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1361,7 +666,7 @@ var sleepWithRawHttp = actor({
     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 });
+      c.log.info({ msg: "starting long fetch request", duration });
       await new Promise((resolve2) => setTimeout(resolve2, duration));
       c.log.info("finished long fetch request");
       return new Response(JSON.stringify({ completed: true }), {
@@ -1384,8 +689,6 @@ var sleepWithRawHttp = actor({
   }
 });
 var sleepWithRawWebSocket = actor({
-  onAuth: () => {
-  },
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1395,7 +698,8 @@ var sleepWithRawWebSocket = actor({
   },
   onWebSocket: (c, websocket, opts) => {
     c.state.connectionCount += 1;
-    c.log.info("websocket connected", {
+    c.log.info({
+      msg: "websocket connected",
       connectionCount: c.state.connectionCount
     });
     websocket.send(
@@ -1428,7 +732,8 @@ var sleepWithRawWebSocket = actor({
     });
     websocket.addEventListener("close", () => {
       c.state.connectionCount -= 1;
-      c.log.info("websocket disconnected", {
+      c.log.info({
+        msg: "websocket disconnected",
         connectionCount: c.state.connectionCount
       });
     });
@@ -1447,8 +752,6 @@ var sleepWithRawWebSocket = actor({
   }
 });
 var sleepWithNoSleepOption = actor({
-  onAuth: () => {
-  },
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1470,30 +773,30 @@ var sleepWithNoSleepOption = actor({
 // 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) => {
+  describe5.skipIf((_a = driverTestConfig.skip) == null ? void 0 : _a.sleep)("Actor Sleep Tests", () => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await waitFor(driverTestConfig, 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("actor sleep persists state with connect", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await sleepActor.triggerSleep();
       await sleepActor.dispose();
@@ -1501,108 +804,108 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor2 = client.sleep.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor2.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("actor automatically sleeps after timeout", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("actor automatically sleeps after timeout with connect", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(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);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("rpc calls keep actor awake", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("alarms keep actor awake", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
     });
-    test6("alarms wake actors", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(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);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("long running rpcs keep actor awake", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       const waitPromise = new Promise(
         (resolve2) => sleepActor.once("waiting", resolve2)
@@ -1614,19 +917,19 @@ function runActorSleepTests(driverTestConfig) {
       await longRunningPromise;
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(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);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("active raw websockets keep actor awake", async (c) => {
+    test5("active raw websockets keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1634,8 +937,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawWebSocket.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       const ws = await sleepActor.websocket();
       await new Promise((resolve2, reject) => {
@@ -1660,18 +963,18 @@ function runActorSleepTests(driverTestConfig) {
           }
         };
       });
-      expect6(counts.sleepCount).toBe(0);
-      expect6(counts.startCount).toBe(1);
+      expect5(counts.sleepCount).toBe(0);
+      expect5(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);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("active raw fetch requests keep actor awake", async (c) => {
+    test5("active raw fetch requests keep actor awake", async (c) => {
       const { client, endpoint: baseUrl } = await setupDriverTest(
         c,
         driverTestConfig
@@ -1679,8 +982,8 @@ function runActorSleepTests(driverTestConfig) {
       const sleepActor = client.sleepWithRawHttp.getOrCreate();
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       const fetchDuration = SLEEP_TIMEOUT + 100;
       const fetchPromise = sleepActor.fetch(
@@ -1688,67 +991,67 @@ function runActorSleepTests(driverTestConfig) {
       );
       const response = await fetchPromise;
       const result = await response.json();
-      expect6(result.completed).toBe(true);
+      expect5(result.completed).toBe(true);
       {
         const { startCount, sleepCount, requestCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
-        expect6(requestCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
+        expect5(requestCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(1);
-        expect6(startCount).toBe(2);
+        expect5(sleepCount).toBe(1);
+        expect5(startCount).toBe(2);
       }
     });
-    test6("noSleep option disables sleeping", async (c) => {
+    test5("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);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
-        expect6(sleepCount).toBe(0);
-        expect6(startCount).toBe(1);
+        expect5(sleepCount).toBe(0);
+        expect5(startCount).toBe(1);
       }
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-state.ts
-import { describe as describe7, expect as expect7, test as test7 } from "vitest";
+import { describe as describe6, expect as expect6, test as test6 } from "vitest";
 function runActorStateTests(driverTestConfig) {
-  describe7("Actor State Tests", () => {
-    describe7("State Persistence", () => {
-      test7("persists state between actor instances", async (c) => {
+  describe6("Actor State Tests", () => {
+    describe6("State Persistence", () => {
+      test6("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);
+        expect6(initialCount).toBe(5);
         const sameInstance = client.counter.getOrCreate();
         const persistedCount = await sameInstance.increment(3);
-        expect7(persistedCount).toBe(8);
+        expect6(persistedCount).toBe(8);
       });
-      test7("restores state after actor disconnect/reconnect", async (c) => {
+      test6("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);
+        expect6(persistedCount).toBe(5);
       });
-      test7("maintains separate state for different actors", async (c) => {
+      test6("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);
@@ -1756,8 +1059,8 @@ function runActorStateTests(driverTestConfig) {
         await counterB.increment(10);
         const countA = await counterA.increment(0);
         const countB = await counterB.increment(0);
-        expect7(countA).toBe(5);
-        expect7(countB).toBe(10);
+        expect6(countA).toBe(5);
+        expect6(countB).toBe(10);
       });
     });
   });
@@ -1765,101 +1068,101 @@ function runActorStateTests(driverTestConfig) {
 
 // src/driver-test-suite/tests/actor-driver.ts
 function runActorDriverTests(driverTestConfig) {
-  describe8("Actor Driver Tests", () => {
+  describe7("Actor Driver Tests", () => {
     runActorStateTests(driverTestConfig);
     runActorScheduleTests(driverTestConfig);
   });
 }
 function runActorDriverTestsWithTransport(driverTestConfig) {
-  describe8("Actor Driver Tests", () => {
+  describe7("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";
+import { describe as describe8, expect as expect7, test as test7 } from "vitest";
 function runActorErrorHandlingTests(driverTestConfig) {
-  describe9("Actor Error Handling Tests", () => {
-    describe9("UserError Handling", () => {
-      test8("should handle simple UserError with message", async (c) => {
+  describe8("Actor Error Handling Tests", () => {
+    describe8("UserError Handling", () => {
+      test7("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);
+          expect7(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toBe("Simple error message");
-          expect8(error.code).toBe("user_error");
-          expect8(error.metadata).toBeUndefined();
+          expect7(error.message).toBe("Simple error message");
+          expect7(error.code).toBe("user_error");
+          expect7(error.metadata).toBeUndefined();
         }
       });
-      test8("should handle detailed UserError with code and metadata", async (c) => {
+      test7("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);
+          expect7(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();
+          expect7(error.message).toBe("Detailed error message");
+          expect7(error.code).toBe("detailed_error");
+          expect7(error.metadata).toBeDefined();
+          expect7(error.metadata.reason).toBe("test");
+          expect7(error.metadata.timestamp).toBeDefined();
         }
       });
     });
-    describe9("Internal Error Handling", () => {
-      test8("should convert internal errors to safe format", async (c) => {
+    describe8("Internal Error Handling", () => {
+      test7("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);
+          expect7(true).toBe(false);
         } catch (error) {
           if (driverTestConfig.clientType === "http") {
-            expect8(error.code).toBe(INTERNAL_ERROR_CODE);
-            expect8(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
+            expect7(error.code).toBe(INTERNAL_ERROR_CODE);
+            expect7(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");
+            expect7(error.code).toBe(INTERNAL_ERROR_CODE);
+            expect7(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) => {
+    describe8.skip("Action Timeout", () => {
+      test7("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);
+          expect7(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toMatch(/timed out/i);
+          expect7(error.message).toMatch(/timed out/i);
         }
       });
-      test8("should successfully run actions within timeout", async (c) => {
+      test7("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");
+        expect7(result).toBe("Completed after 200ms");
       });
-      test8("should respect different timeouts for different actors", async (c) => {
+      test7("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);
+          expect7(true).toBe(false);
         } catch (error) {
-          expect8(error.message).toMatch(/timed out/i);
+          expect7(error.message).toMatch(/timed out/i);
         }
         const quickResult = await client.customTimeoutActor.getOrCreate().quickAction();
-        expect8(quickResult).toBe("Quick action completed");
+        expect7(quickResult).toBe("Quick action completed");
       });
     });
-    describe9("Error Recovery", () => {
-      test8("should continue working after errors", async (c) => {
+    describe8("Error Recovery", () => {
+      test7("should continue working after errors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.errorHandlingActor.getOrCreate();
         try {
@@ -1867,150 +1170,173 @@ function runActorErrorHandlingTests(driverTestConfig) {
         } catch (error) {
         }
         const result = await handle.successfulAction();
-        expect8(result).toBe("success");
+        expect7(result).toBe("success");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-handle.ts
-import { describe as describe10, expect as expect9, test as test9 } from "vitest";
+import { describe as describe9, expect as expect8, test as test8 } from "vitest";
 function runActorHandleTests(driverTestConfig) {
-  describe10("Actor Handle Tests", () => {
-    describe10("Access Methods", () => {
-      test9("should use .get() to access a actor", async (c) => {
+  describe9("Actor Handle Tests", () => {
+    describe9("Access Methods", () => {
+      test8("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);
+        expect8(count).toBe(5);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(5);
+        expect8(retrievedCount).toBe(5);
       });
-      test9("should use .getForId() to access a actor by ID", async (c) => {
+      test8("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);
+        expect8(count).toBe(3);
         const newCount = await idHandle.increment(4);
-        expect9(newCount).toBe(7);
+        expect8(newCount).toBe(7);
       });
-      test9("should use .getOrCreate() to access or create a actor", async (c) => {
+      test8("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);
+        expect8(count).toBe(7);
         const sameHandle = client.counter.getOrCreate([
           "test-get-or-create-handle"
         ]);
         const retrievedCount = await sameHandle.getCount();
-        expect9(retrievedCount).toBe(7);
+        expect8(retrievedCount).toBe(7);
       });
-      test9("should use (await create()) to create and return a handle", async (c) => {
+      test8("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);
+        expect8(count).toBe(9);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(9);
+        expect8(retrievedCount).toBe(9);
+      });
+      test8("errors when calling create twice with the same key", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const key = ["duplicate-create-handle", crypto.randomUUID()];
+        await client.counter.create(key);
+        try {
+          await client.counter.create(key);
+          expect8.fail("did not error on duplicate create");
+        } catch (err) {
+          expect8(err.group).toBe("actor");
+          expect8(err.code).toBe("already_exists");
+        }
+      });
+      test8(".get().resolve() errors for non-existent actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const missingId = `nonexistent-${crypto.randomUUID()}`;
+        try {
+          await client.counter.get([missingId]).resolve();
+          expect8.fail("did not error for get().resolve() on missing actor");
+        } catch (err) {
+          expect8(err.group).toBe("actor");
+          expect8(err.code).toBe("not_found");
+        }
       });
     });
-    describe10("Action Functionality", () => {
-      test9("should call actions directly on the handle", async (c) => {
+    describe9("Action Functionality", () => {
+      test8("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);
+        expect8(count1).toBe(3);
         const count2 = await handle.increment(5);
-        expect9(count2).toBe(8);
+        expect8(count2).toBe(8);
         const retrievedCount = await handle.getCount();
-        expect9(retrievedCount).toBe(8);
+        expect8(retrievedCount).toBe(8);
       });
-      test9("should handle independent handles to the same actor", async (c) => {
+      test8("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);
+        expect8(count).toBe(3);
         const finalCount = await handle2.increment(4);
-        expect9(finalCount).toBe(7);
+        expect8(finalCount).toBe(7);
         const checkCount = await handle1.getCount();
-        expect9(checkCount).toBe(7);
+        expect8(checkCount).toBe(7);
       });
-      test9("should resolve a actor's ID", async (c) => {
+      test8("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("");
+        expect8(typeof actorId).toBe("string");
+        expect8(actorId).not.toBe("");
         const idHandle = client.counter.getForId(actorId);
         const count = await idHandle.getCount();
-        expect9(count).toBe(1);
+        expect8(count).toBe(1);
       });
     });
-    describe10("Lifecycle Hooks", () => {
-      test9("should trigger lifecycle hooks on actor creation", async (c) => {
+    describe9("Lifecycle Hooks", () => {
+      test8("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");
+        expect8(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);
+        expect8(events).toContain("onStart");
+        expect8(events.filter((e) => e === "onStart").length).toBe(1);
       });
-      test9("should trigger lifecycle hooks for each Action call", async (c) => {
+      test8("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");
+        expect8(initialEvents).toContain("onStart");
+        expect8(initialEvents).not.toContain("onBeforeConnect");
+        expect8(initialEvents).not.toContain("onConnect");
+        expect8(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(
+        expect8(eventsAfterAction).toContain("onBeforeConnect");
+        expect8(eventsAfterAction).toContain("onConnect");
+        expect8(eventsAfterAction).toContain("onDisconnect");
+        expect8(
           eventsAfterAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(1);
-        expect9(eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
+        expect8(eventsAfterAction.filter((e) => e === "onConnect").length).toBe(
           1
         );
-        expect9(
+        expect8(
           eventsAfterAction.filter((e) => e === "onDisconnect").length
         ).toBe(1);
         await trackingHandle.increment(10);
         const eventsAfterSecondAction = await viewHandle.getEvents();
-        expect9(
+        expect8(
           eventsAfterSecondAction.filter((e) => e === "onBeforeConnect").length
         ).toBe(2);
-        expect9(
+        expect8(
           eventsAfterSecondAction.filter((e) => e === "onConnect").length
         ).toBe(2);
-        expect9(
+        expect8(
           eventsAfterSecondAction.filter((e) => e === "onDisconnect").length
         ).toBe(2);
       });
-      test9("should trigger lifecycle hooks for each Action call across multiple handles", async (c) => {
+      test8("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"
@@ -2026,35 +1352,35 @@ function runActorHandleTests(driverTestConfig) {
         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);
+        expect8(events.filter((e) => e === "onStart").length).toBe(1);
+        expect8(events.filter((e) => e === "onBeforeConnect").length).toBe(2);
+        expect8(events.filter((e) => e === "onConnect").length).toBe(2);
+        expect8(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";
+import { describe as describe10, expect as expect9, test as test9 } from "vitest";
 function runActorInlineClientTests(driverTestConfig) {
-  describe11("Actor Inline Client Tests", () => {
-    describe11("Stateless Client Calls", () => {
-      test10("should make stateless calls to other actors", async (c) => {
+  describe10("Actor Inline Client Tests", () => {
+    describe10("Stateless Client Calls", () => {
+      test9("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);
+        expect9(result).toBe(5);
         const counterState = await inlineClientHandle.getCounterState();
-        expect10(counterState).toBe(5);
+        expect9(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");
+        expect9(messages).toHaveLength(2);
+        expect9(messages[0]).toContain("Called counter.increment(5), result: 5");
+        expect9(messages[1]).toContain("Got counter state: 5");
       });
-      test10("should handle multiple stateless calls", async (c) => {
+      test9("should handle multiple stateless calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate([
           "inline-client-multi"
@@ -2063,56 +1389,56 @@ function runActorInlineClientTests(driverTestConfig) {
         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);
+        expect9(result1).toBe(3);
+        expect9(result2).toBe(10);
+        expect9(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(
+        expect9(messages).toHaveLength(3);
+        expect9(messages[0]).toContain("Called counter.increment(3), result: 3");
+        expect9(messages[1]).toContain(
           "Called counter.increment(7), result: 10"
         );
-        expect10(messages[2]).toContain("Got counter state: 10");
+        expect9(messages[2]).toContain("Got counter state: 10");
       });
     });
-    describe11("Stateful Client Calls", () => {
-      test10("should connect to other actors and receive events", async (c) => {
+    describe10("Stateful Client Calls", () => {
+      test9("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]);
+        expect9(result.result1).toBe(4);
+        expect9(result.result2).toBe(12);
+        expect9(result.events).toEqual([4, 12]);
         const messages = await inlineClientHandle.getMessages();
-        expect10(messages).toHaveLength(1);
-        expect10(messages[0]).toContain(
+        expect9(messages).toHaveLength(1);
+        expect9(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]");
+        expect9(messages[0]).toContain("results: 4, 12");
+        expect9(messages[0]).toContain("events: [4,12]");
       });
-      test10("should handle stateful connection independently", async (c) => {
+      test9("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]);
+        expect9(result.result1).toBe(2);
+        expect9(result.result2).toBe(6);
+        expect9(result.events).toEqual([2, 6]);
         const messages = await inlineClientHandle.getMessages();
-        expect10(messages).toHaveLength(1);
-        expect10(messages[0]).toContain(
+        expect9(messages).toHaveLength(1);
+        expect9(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) => {
+    describe10("Mixed Client Usage", () => {
+      test9("should handle both stateless and stateful calls", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const inlineClientHandle = client.inlineClientActor.getOrCreate([
           "inline-client-mixed"
@@ -2120,15 +1446,15 @@ function runActorInlineClientTests(driverTestConfig) {
         await inlineClientHandle.clearMessages();
         await inlineClientHandle.callCounterIncrement(1);
         const statelessResult = await inlineClientHandle.getCounterState();
-        expect10(statelessResult).toBe(1);
+        expect9(statelessResult).toBe(1);
         const statefulResult = await inlineClientHandle.connectToCounterAndIncrement(3);
-        expect10(statefulResult.result1).toBe(3);
-        expect10(statefulResult.result2).toBe(9);
+        expect9(statefulResult.result1).toBe(3);
+        expect9(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(
+        expect9(messages).toHaveLength(3);
+        expect9(messages[0]).toContain("Called counter.increment(1), result: 1");
+        expect9(messages[1]).toContain("Got counter state: 1");
+        expect9(messages[2]).toContain(
           "Connected to counter, incremented by 3 and 6"
         );
       });
@@ -2137,11 +1463,11 @@ function runActorInlineClientTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-inspector.ts
-import { describe as describe12, expect as expect11, test as test11 } from "vitest";
+import { describe as describe11, expect as expect10, test as test10 } from "vitest";
 function runActorInspectorTests(driverTestConfig) {
-  describe12("Actor Inspector Tests", () => {
-    describe12("Manager Inspector", () => {
-      test11("should respond to ping", async (c) => {
+  describe11("Actor Inspector Tests", () => {
+    describe11("Manager Inspector", () => {
+      test10("should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(`${endpoint}/inspect`, {
           headers: {
@@ -2149,11 +1475,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.ping.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual({ message: "pong" });
+        expect10(data).toEqual({ message: "pong" });
       });
-      test11("should get actors with pagination", async (c) => {
+      test10("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"]);
@@ -2165,16 +1491,16 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "1" }
         });
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({ key: ["test-actor-1"] })
+        expect10(data).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({ key: ["test-actor-1"] })
           ])
         );
-        expect11(data.length).toBe(1);
+        expect10(data.length).toBe(1);
       });
-      test11("should get all actors with pagination", async (c) => {
+      test10("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"];
@@ -2188,22 +1514,22 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "5" }
         });
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({
-              id: expect11.any(String),
+        expect10(data).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({
+              id: expect10.any(String),
               key: actorKey1
             }),
-            expect11.objectContaining({
-              id: expect11.any(String),
+            expect10.objectContaining({
+              id: expect10.any(String),
               key: actorKey2
             })
           ])
         );
       });
-      test11("should handle invalid limit parameter", async (c) => {
+      test10("should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(`${endpoint}/inspect`, {
           headers: {
@@ -2213,9 +1539,9 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actors.$get({
           query: { limit: "0" }
         });
-        expect11(response.status).toBe(400);
+        expect10(response.status).toBe(400);
       });
-      test11("should create a new actor", async (c) => {
+      test10("should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(`${endpoint}/inspect`, {
           headers: {
@@ -2229,17 +1555,17 @@ function runActorInspectorTests(driverTestConfig) {
             input: {}
           }
         });
-        expect11(response.status).toBe(201);
+        expect10(response.status).toBe(201);
         const data = await response.json();
-        expect11(data).toEqual(
-          expect11.objectContaining({
-            id: expect11.any(String),
+        expect10(data).toEqual(
+          expect10.objectContaining({
+            id: expect10.any(String),
             name: "default",
             key: ["test-create-actor"]
           })
         );
       });
-      test11("should get builds", async (c) => {
+      test10("should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(`${endpoint}/inspect`, {
           headers: {
@@ -2247,15 +1573,15 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.builds.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({ name: expect11.any(String) })
+        expect10(data).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({ name: expect10.any(String) })
           ])
         );
       });
-      test11("should get actor by id", async (c) => {
+      test10("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();
@@ -2267,11 +1593,11 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actor[":id"].$get({
           param: { id: actorId }
         });
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toHaveProperty("id", actorId);
+        expect10(data).toHaveProperty("id", actorId);
       });
-      test11("should return 404 for non-existent actor", async (c) => {
+      test10("should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const http = createManagerInspectorClient(`${endpoint}/inspect`, {
           headers: {
@@ -2281,11 +1607,11 @@ function runActorInspectorTests(driverTestConfig) {
         const response = await http.actor[":id"].$get({
           param: { id: "non-existent-id" }
         });
-        expect11(response.status).toBe(404);
+        expect10(response.status).toBe(404);
         const data = await response.json();
-        expect11(data).toEqual({ error: "Actor not found" });
+        expect10(data).toEqual({ error: "Actor not found" });
       });
-      test11("should get bootstrap data", async (c) => {
+      test10("should get bootstrap data", async (c) => {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
@@ -2295,11 +1621,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.bootstrap.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data.actors).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({
+        expect10(data.actors).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({
               key: ["test-bootstrap"],
               name: "counter"
             })
@@ -2307,8 +1633,8 @@ function runActorInspectorTests(driverTestConfig) {
         );
       });
     });
-    describe12("Actor Inspector", () => {
-      test11("should handle actor not found", async (c) => {
+    describe11("Actor Inspector", () => {
+      test10("should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
         const http = createActorInspectorClient(`${endpoint}/actors/inspect`, {
@@ -2320,9 +1646,9 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.ping.$get();
-        expect11(response.ok).toBe(false);
+        expect10(response.ok).toBe(false);
       });
-      test11("should respond to ping", async (c) => {
+      test10("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();
@@ -2335,11 +1661,11 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.ping.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual({ message: "pong" });
+        expect10(data).toEqual({ message: "pong" });
       });
-      test11("should get actor state", async (c) => {
+      test10("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();
@@ -2353,16 +1679,16 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.state.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual({
+        expect10(data).toEqual({
           enabled: true,
-          state: expect11.objectContaining({
+          state: expect10.objectContaining({
             count: 5
           })
         });
       });
-      test11("should update actor state with replace", async (c) => {
+      test10("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();
@@ -2379,14 +1705,14 @@ function runActorInspectorTests(driverTestConfig) {
             replace: { count: 10 }
           }
         });
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual({
+        expect10(data).toEqual({
           enabled: true,
           state: { count: 10 }
         });
       });
-      test11("should update actor state with patch", async (c) => {
+      test10("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();
@@ -2410,16 +1736,16 @@ function runActorInspectorTests(driverTestConfig) {
             ]
           }
         });
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual({
+        expect10(data).toEqual({
           enabled: true,
-          state: expect11.objectContaining({
+          state: expect10.objectContaining({
             count: 7
           })
         });
       });
-      test11("should get actor connections", async (c) => {
+      test10("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();
@@ -2434,17 +1760,17 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.connections.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data.connections).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({
-              id: expect11.any(String)
+        expect10(data.connections).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({
+              id: expect10.any(String)
             })
           ])
         );
       });
-      test11("should get actor events", async (c) => {
+      test10("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();
@@ -2459,18 +1785,18 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.events.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data.events).toEqual(
-          expect11.arrayContaining([
-            expect11.objectContaining({
+        expect10(data.events).toEqual(
+          expect10.arrayContaining([
+            expect10.objectContaining({
               type: "broadcast",
-              id: expect11.any(String)
+              id: expect10.any(String)
             })
           ])
         );
       });
-      test11("should clear actor events", async (c) => {
+      test10("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();
@@ -2486,21 +1812,21 @@ function runActorInspectorTests(driverTestConfig) {
         });
         {
           const response2 = await http.events.$get();
-          expect11(response2.status).toBe(200);
+          expect10(response2.status).toBe(200);
           const data = await response2.json();
-          expect11(data.events).toEqual(
-            expect11.arrayContaining([
-              expect11.objectContaining({
+          expect10(data.events).toEqual(
+            expect10.arrayContaining([
+              expect10.objectContaining({
                 type: "broadcast",
-                id: expect11.any(String)
+                id: expect10.any(String)
               })
             ])
           );
         }
         const response = await http.events.clear.$post();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
       });
-      test11("should get actor rpcs", async (c) => {
+      test10("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();
@@ -2513,15 +1839,15 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.rpcs.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toEqual(
-          expect11.objectContaining({
-            rpcs: expect11.arrayContaining(["increment", "getCount"])
+        expect10(data).toEqual(
+          expect10.objectContaining({
+            rpcs: expect10.arrayContaining(["increment", "getCount"])
           })
         );
       });
-      test11.skip("should get actor database info", async (c) => {
+      test10.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();
@@ -2534,18 +1860,18 @@ function runActorInspectorTests(driverTestConfig) {
           }
         });
         const response = await http.db.$get();
-        expect11(response.status).toBe(200);
+        expect10(response.status).toBe(200);
         const data = await response.json();
-        expect11(data).toHaveProperty("enabled");
-        expect11(typeof data.enabled).toBe("boolean");
+        expect10(data).toHaveProperty("enabled");
+        expect10(typeof data.enabled).toBe("boolean");
         if (data.enabled) {
-          expect11(data).toHaveProperty("db");
-          expect11(Array.isArray(data.db)).toBe(true);
+          expect10(data).toHaveProperty("db");
+          expect10(Array.isArray(data.db)).toBe(true);
         } else {
-          expect11(data.db).toBe(null);
+          expect10(data.db).toBe(null);
         }
       });
-      test11.skip("should execute database query when database is enabled", async (c) => {
+      test10.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();
@@ -2566,9 +1892,9 @@ function runActorInspectorTests(driverTestConfig) {
               params: []
             }
           });
-          expect11(queryResponse.status).toBe(200);
+          expect10(queryResponse.status).toBe(200);
           const queryData = await queryResponse.json();
-          expect11(queryData).toHaveProperty("result");
+          expect10(queryData).toHaveProperty("result");
         } else {
           const queryResponse = await http.db.$post({
             json: {
@@ -2576,9 +1902,9 @@ function runActorInspectorTests(driverTestConfig) {
               params: []
             }
           });
-          expect11(queryResponse.status).toBe(200);
+          expect10(queryResponse.status).toBe(200);
           const queryData = await queryResponse.json();
-          expect11(queryData).toEqual({ enabled: false });
+          expect10(queryData).toEqual({ enabled: false });
         }
       });
     });
@@ -2586,25 +1912,25 @@ function runActorInspectorTests(driverTestConfig) {
 }
 
 // src/driver-test-suite/tests/actor-metadata.ts
-import { describe as describe13, expect as expect12, test as test12 } from "vitest";
+import { describe as describe12, expect as expect11, test as test11 } from "vitest";
 function runActorMetadataTests(driverTestConfig) {
-  describe13("Actor Metadata Tests", () => {
-    describe13("Actor Name", () => {
-      test12("should provide access to actor name", async (c) => {
+  describe12("Actor Metadata Tests", () => {
+    describe12("Actor Name", () => {
+      test11("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");
+        expect11(actorName).toBe("metadataActor");
       });
-      test12("should preserve actor name in state during onStart", async (c) => {
+      test11("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");
+        expect11(storedName).toBe("metadataActor");
       });
     });
-    describe13("Actor Tags", () => {
-      test12("should provide access to tags", async (c) => {
+    describe12("Actor Tags", () => {
+      test11("should provide access to tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2612,12 +1938,12 @@ function runActorMetadataTests(driverTestConfig) {
           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");
+        expect11(tags).toHaveProperty("env");
+        expect11(tags.env).toBe("test");
+        expect11(tags).toHaveProperty("purpose");
+        expect11(tags.purpose).toBe("metadata-test");
       });
-      test12("should allow accessing individual tags", async (c) => {
+      test11("should allow accessing individual tags", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const handle = client.metadataActor.getOrCreate();
         await handle.setupTestTags({
@@ -2627,203 +1953,205 @@ function runActorMetadataTests(driverTestConfig) {
         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();
+        expect11(category).toBe("test-actor");
+        expect11(version).toBe("1.0");
+        expect11(nonexistent).toBeNull();
       });
     });
-    describe13("Metadata Structure", () => {
-      test12("should provide complete metadata object", async (c) => {
+    describe12("Metadata Structure", () => {
+      test11("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");
+        expect11(metadata).toHaveProperty("name");
+        expect11(metadata.name).toBe("metadataActor");
+        expect11(metadata).toHaveProperty("tags");
+        expect11(metadata.tags).toHaveProperty("type");
+        expect11(metadata.tags.type).toBe("metadata-test");
+        expect11(metadata).toHaveProperty("region");
+        expect11(metadata.region).toBe("us-west-1");
       });
     });
-    describe13("Region Information", () => {
-      test12("should retrieve region information", async (c) => {
+    describe12("Region Information", () => {
+      test11("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");
+        expect11(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";
+import { describe as describe13, expect as expect12, test as test12 } from "vitest";
 function runActorOnStateChangeTests(driverTestConfig) {
-  describe14("Actor onStateChange Tests", () => {
-    test13("triggers onStateChange when state is modified", async (c) => {
+  describe13("Actor onStateChange Tests", () => {
+    test12("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);
+      expect12(changeCount).toBe(1);
     });
-    test13("triggers onChange multiple times for multiple state changes", async (c) => {
+    test12("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);
+      expect12(changeCount).toBe(3);
     });
-    test13("does NOT trigger onChange for read-only actions", async (c) => {
+    test12("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);
+      expect12(value).toBe(5);
       const changeCount = await actor2.getChangeCount();
-      expect13(changeCount).toBe(1);
+      expect12(changeCount).toBe(1);
     });
-    test13("does NOT trigger onChange for computed values", async (c) => {
+    test12("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);
+        expect12(changeCount).toBe(1);
       }
       const doubled = await actor2.getDoubled();
-      expect13(doubled).toBe(6);
+      expect12(doubled).toBe(6);
       {
         const changeCount = await actor2.getChangeCount();
-        expect13(changeCount).toBe(1);
+        expect12(changeCount).toBe(1);
       }
     });
-    test13("simple: connect, call action, dispose does NOT trigger onChange", async (c) => {
+    test12("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);
+      expect12(value).toBe(0);
       await connection.dispose();
       const changeCount = await actor2.getChangeCount();
-      expect13(changeCount).toBe(0);
+      expect12(changeCount).toBe(0);
     });
   });
 }
 
 // src/driver-test-suite/tests/actor-vars.ts
-import { describe as describe15, expect as expect14, test as test14 } from "vitest";
+import { describe as describe14, expect as expect13, test as test13 } from "vitest";
 function runActorVarsTests(driverTestConfig) {
-  describe15("Actor Variables", () => {
-    describe15("Static vars", () => {
-      test14("should provide access to static vars", async (c) => {
+  describe14("Actor Variables", () => {
+    describe14("Static vars", () => {
+      test13("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" });
+        expect13(result).toEqual({ counter: 42, name: "test-actor" });
         const name = await instance.getName();
-        expect14(name).toBe("test-actor");
+        expect13(name).toBe("test-actor");
       });
     });
-    describe15("Deep cloning of static vars", () => {
-      test14("should deep clone static vars between actor instances", async (c) => {
+    describe14("Deep cloning of static vars", () => {
+      test13("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");
+        expect13(modifiedVars.nested.value).toBe("modified");
+        expect13(modifiedVars.nested.array).toContain(4);
+        expect13(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");
+        expect13(instance2Vars.nested.value).toBe("original");
+        expect13(instance2Vars.nested.array).toEqual([1, 2, 3]);
+        expect13(instance2Vars.nested.obj.key).toBe("value");
       });
     });
-    describe15("createVars", () => {
-      test14("should support dynamic vars creation", async (c) => {
+    describe14("createVars", () => {
+      test13("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+$/);
+        expect13(vars).toHaveProperty("random");
+        expect13(vars).toHaveProperty("computed");
+        expect13(typeof vars.random).toBe("number");
+        expect13(typeof vars.computed).toBe("string");
+        expect13(vars.computed).toMatch(/^Actor-\d+$/);
       });
-      test14("should create different vars for different instances", async (c) => {
+      test13("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);
+        expect13(vars1.id).not.toBe(vars2.id);
       });
     });
-    describe15("Driver Context", () => {
-      test14("should provide access to driver context", async (c) => {
+    describe14("Driver Context", () => {
+      test13("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");
+        expect13(vars).toHaveProperty("hasDriverCtx");
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/manager-driver.ts
-import { describe as describe16, expect as expect15, test as test15 } from "vitest";
+import { describe as describe15, expect as expect14, test as test14 } from "vitest";
 function runManagerDriverTests(driverTestConfig) {
-  describe16("Manager Driver Tests", () => {
-    describe16("Client Connection Methods", () => {
-      test15("connect() - finds or creates a actor", async (c) => {
+  describe15("Manager Driver Tests", () => {
+    describe15("Client Connection Methods", () => {
+      test14("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);
+        expect14(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);
+        expect14(countB).toBe(10);
       });
-      test15("throws ActorAlreadyExists when creating duplicate actors", async (c) => {
+      test14("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");
+          expect14.fail("did not error on duplicate create");
         } catch (err) {
-          expect15(err.code).toBe("actor_already_exists");
+          expect14(err.group).toBe("actor");
+          expect14(err.code).toBe("already_exists");
         }
         const count = await counter.increment(0);
-        expect15(count).toBe(5);
+        expect14(count).toBe(5);
       });
     });
-    describe16("Connection Options", () => {
-      test15("get without create prevents actor creation", async (c) => {
+    describe15("Connection Options", () => {
+      test14("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");
+          expect14.fail("did not error for get");
         } catch (err) {
-          expect15(err.code).toBe("actor_not_found");
+          expect14(err.group).toBe("actor");
+          expect14(err.code).toBe("not_found");
         }
         const createdCounter = client.counter.getOrCreate(nonexistentId);
         await createdCounter.increment(3);
         const retrievedCounter = client.counter.get(nonexistentId);
         const count = await retrievedCounter.increment(0);
-        expect15(count).toBe(3);
+        expect14(count).toBe(3);
       });
-      test15("connection params are passed to actors", async (c) => {
+      test14("connection params are passed to actors", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const counter = client.counter.getOrCreate(void 0, {
           params: {
@@ -2834,20 +2162,20 @@ function runManagerDriverTests(driverTestConfig) {
         });
         await counter.increment(1);
         const count = await counter.increment(0);
-        expect15(count).toBe(1);
+        expect14(count).toBe(1);
       });
     });
-    describe16("Actor Creation & Retrieval", () => {
-      test15("creates and retrieves actors by ID", async (c) => {
+    describe15("Actor Creation & Retrieval", () => {
+      test14("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);
+        expect14(count).toBe(10);
       });
-      test15("passes input to actor during creation", async (c) => {
+      test14("passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const testInput = {
           name: "test-actor",
@@ -2858,17 +2186,17 @@ function runManagerDriverTests(driverTestConfig) {
           input: testInput
         });
         const inputs = await actor2.getInputs();
-        expect15(inputs.initialInput).toEqual(testInput);
-        expect15(inputs.onCreateInput).toEqual(testInput);
+        expect14(inputs.initialInput).toEqual(testInput);
+        expect14(inputs.onCreateInput).toEqual(testInput);
       });
-      test15("input is undefined when not provided", async (c) => {
+      test14("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();
+        expect14(inputs.initialInput).toBeUndefined();
+        expect14(inputs.onCreateInput).toBeUndefined();
       });
-      test15("getOrCreate passes input to actor during creation", async (c) => {
+      test14("getOrCreate passes input to actor during creation", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const uniqueKey = [`input-test-${crypto.randomUUID()}`];
         const testInput = {
@@ -2880,16 +2208,16 @@ function runManagerDriverTests(driverTestConfig) {
           createWithInput: testInput
         });
         const inputs = await actor2.getInputs();
-        expect15(inputs.initialInput).toEqual(testInput);
-        expect15(inputs.onCreateInput).toEqual(testInput);
+        expect14(inputs.initialInput).toEqual(testInput);
+        expect14(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);
+        expect14(existingInputs.initialInput).toEqual(testInput);
+        expect14(existingInputs.onCreateInput).toEqual(testInput);
       });
     });
-    describe16("Key Matching", () => {
-      test15("matches actors only with exactly the same keys", async (c) => {
+    describe15("Key Matching", () => {
+      test14("matches actors only with exactly the same keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const originalCounter = client.counter.getOrCreate([
           "counter-match",
@@ -2903,37 +2231,37 @@ function runManagerDriverTests(driverTestConfig) {
           "us-east"
         ]);
         const exactMatchCount = await exactMatchCounter.increment(0);
-        expect15(exactMatchCount).toBe(10);
+        expect14(exactMatchCount).toBe(10);
         const subsetMatchCounter = client.counter.getOrCreate([
           "counter-match",
           "test"
         ]);
         const subsetMatchCount = await subsetMatchCounter.increment(0);
-        expect15(subsetMatchCount).toBe(0);
+        expect14(subsetMatchCount).toBe(0);
         const singleKeyCounter = client.counter.getOrCreate(["counter-match"]);
         const singleKeyCount = await singleKeyCounter.increment(0);
-        expect15(singleKeyCount).toBe(0);
+        expect14(singleKeyCount).toBe(0);
       });
-      test15("string key matches array with single string key", async (c) => {
+      test14("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);
+        expect14(count).toBe(7);
       });
-      test15("undefined key matches empty array key and no key", async (c) => {
+      test14("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);
+        expect14(emptyArrayCount).toBe(12);
         const noKeyCounter = client.counter.getOrCreate();
         const noKeyCount = await noKeyCounter.increment(0);
-        expect15(noKeyCount).toBe(12);
+        expect14(noKeyCount).toBe(12);
       });
-      test15("no keys does not match actors with keys", async (c) => {
+      test14("no keys does not match actors with keys", async (c) => {
         const { client } = await setupDriverTest(c, driverTestConfig);
         const keyedCounter = client.counter.getOrCreate([
           "counter-with-keys",
@@ -2942,9 +2270,9 @@ function runManagerDriverTests(driverTestConfig) {
         await keyedCounter.increment(15);
         const noKeysCounter = client.counter.getOrCreate();
         const count = await noKeysCounter.increment(10);
-        expect15(count).toBe(10);
+        expect14(count).toBe(10);
       });
-      test15("actors with keys match actors with no keys", async (c) => {
+      test14("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);
@@ -2953,11 +2281,11 @@ function runManagerDriverTests(driverTestConfig) {
           "prod"
         ]);
         const keyedCount = await keyedCounter.increment(0);
-        expect15(keyedCount).toBe(0);
+        expect14(keyedCount).toBe(0);
       });
     });
-    describe16("Multiple Actor Instances", () => {
-      test15("creates multiple actor instances of the same type", async (c) => {
+    describe15("Multiple Actor Instances", () => {
+      test14("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"]);
@@ -2968,35 +2296,35 @@ function runManagerDriverTests(driverTestConfig) {
         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);
+        expect14(await retrieved1.increment(0)).toBe(1);
+        expect14(await retrieved2.increment(0)).toBe(2);
+        expect14(await retrieved3.increment(0)).toBe(3);
       });
-      test15("handles default instance with no explicit ID", async (c) => {
+      test14("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);
+        expect14(count).toBe(5);
       });
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http.ts
-import { describe as describe17, expect as expect16, test as test16 } from "vitest";
+import { describe as describe16, expect as expect15, test as test15 } from "vitest";
 function runRawHttpTests(driverTestConfig) {
-  describe17("raw http", () => {
-    test16("should handle raw HTTP GET requests", async (c) => {
+  describe16("raw http", () => {
+    test15("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);
+      expect15(helloResponse.ok).toBe(true);
       const helloData = await helloResponse.json();
-      expect16(helloData).toEqual({ message: "Hello from actor!" });
+      expect15(helloData).toEqual({ message: "Hello from actor!" });
     });
-    test16("should handle raw HTTP POST requests with echo", async (c) => {
+    test15("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 };
@@ -3007,22 +2335,22 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: JSON.stringify(testData)
       });
-      expect16(echoResponse.ok).toBe(true);
+      expect15(echoResponse.ok).toBe(true);
       const echoData = await echoResponse.json();
-      expect16(echoData).toEqual(testData);
+      expect15(echoData).toEqual(testData);
     });
-    test16("should track state across raw HTTP requests", async (c) => {
+    test15("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);
+      expect15(stateResponse.ok).toBe(true);
       const stateData = await stateResponse.json();
-      expect16(stateData.requestCount).toBe(4);
+      expect15(stateData.requestCount).toBe(4);
     });
-    test16("should pass headers correctly", async (c) => {
+    test15("should pass headers correctly", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpActor.getOrCreate(["headers-test"]);
       const customHeaders = {
@@ -3032,40 +2360,40 @@ function runRawHttpTests(driverTestConfig) {
       const response = await actor2.fetch("api/headers", {
         headers: customHeaders
       });
-      expect16(response.ok).toBe(true);
+      expect15(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");
+      expect15(headers["x-custom-header"]).toBe("test-value");
+      expect15(headers["x-another-header"]).toBe("another-value");
     });
-    test16("should return 404 for unhandled paths", async (c) => {
+    test15("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);
+      expect15(response.ok).toBe(false);
+      expect15(response.status).toBe(404);
     });
-    test16("should return 404 when no onFetch handler defined", async (c) => {
+    test15("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);
+      expect15(response.ok).toBe(false);
+      expect15(response.status).toBe(404);
     });
-    test16("should return 500 error when onFetch returns void", async (c) => {
+    test15("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);
+      expect15(response.ok).toBe(false);
+      expect15(response.status).toBe(500);
       try {
         const errorData = await response.json();
-        expect16(errorData.message).toContain(
+        expect15(errorData.message).toContain(
           "onFetch handler must return a Response"
         );
       } catch {
       }
     });
-    test16("should handle different HTTP methods", async (c) => {
+    test15("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"];
@@ -3075,17 +2403,17 @@ function runRawHttpTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "POST") {
-          expect16(response.ok).toBe(true);
+          expect15(response.ok).toBe(true);
           const data = await response.json();
-          expect16(data).toEqual({ method });
+          expect15(data).toEqual({ method });
         } else if (method === "GET") {
-          expect16(response.status).toBe(404);
+          expect15(response.status).toBe(404);
         } else {
-          expect16(response.status).toBe(404);
+          expect15(response.status).toBe(404);
         }
       }
     });
-    test16("should handle binary data", async (c) => {
+    test15("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]);
@@ -3096,82 +2424,82 @@ function runRawHttpTests(driverTestConfig) {
         },
         body: binaryData
       });
-      expect16(response.ok).toBe(true);
+      expect15(response.ok).toBe(true);
       const responseBuffer = await response.arrayBuffer();
       const responseArray = new Uint8Array(responseBuffer);
-      expect16(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
+      expect15(Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
     });
-    test16("should work with Hono router using createVars", async (c) => {
+    test15("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);
+      expect15(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect16(rootData).toEqual({ message: "Welcome to Hono actor!" });
+      expect15(rootData).toEqual({ message: "Welcome to Hono actor!" });
       const usersResponse = await actor2.fetch("/users");
-      expect16(usersResponse.ok).toBe(true);
+      expect15(usersResponse.ok).toBe(true);
       const users = await usersResponse.json();
-      expect16(users).toEqual([
+      expect15(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
       const userResponse = await actor2.fetch("/users/1");
-      expect16(userResponse.ok).toBe(true);
+      expect15(userResponse.ok).toBe(true);
       const user = await userResponse.json();
-      expect16(user).toEqual({ id: 1, name: "Alice" });
+      expect15(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);
+      expect15(createResponse.ok).toBe(true);
+      expect15(createResponse.status).toBe(201);
       const createdUser = await createResponse.json();
-      expect16(createdUser).toEqual({ id: 3, name: "Charlie" });
+      expect15(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);
+      expect15(updateResponse.ok).toBe(true);
       const updatedUser = await updateResponse.json();
-      expect16(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
+      expect15(updatedUser).toEqual({ id: 1, name: "Alice Updated" });
       const deleteResponse = await actor2.fetch("/users/2", {
         method: "DELETE"
       });
-      expect16(deleteResponse.ok).toBe(true);
+      expect15(deleteResponse.ok).toBe(true);
       const deleteResult = await deleteResponse.json();
-      expect16(deleteResult).toEqual({ message: "User 2 deleted" });
+      expect15(deleteResult).toEqual({ message: "User 2 deleted" });
       const notFoundResponse = await actor2.fetch("/api/unknown");
-      expect16(notFoundResponse.ok).toBe(false);
-      expect16(notFoundResponse.status).toBe(404);
+      expect15(notFoundResponse.ok).toBe(false);
+      expect15(notFoundResponse.status).toBe(404);
     });
-    test16("should handle paths with and without leading slashes", async (c) => {
+    test15("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);
+      expect15(responseWithoutSlash.ok).toBe(true);
       const dataWithoutSlash = await responseWithoutSlash.json();
-      expect16(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
+      expect15(dataWithoutSlash).toEqual({ message: "Hello from actor!" });
       const responseWithSlash = await actor2.fetch("/api/hello");
-      expect16(responseWithSlash.ok).toBe(true);
+      expect15(responseWithSlash.ok).toBe(true);
       const dataWithSlash = await responseWithSlash.json();
-      expect16(dataWithSlash).toEqual({ message: "Hello from actor!" });
+      expect15(dataWithSlash).toEqual({ message: "Hello from actor!" });
     });
-    test16("should not create double slashes in request URLs", async (c) => {
+    test15("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);
+      expect15(response.ok).toBe(true);
       const data = await response.json();
-      expect16(data).toEqual([
+      expect15(data).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test16("should handle forwarded requests correctly without double slashes", async (c) => {
+    test15("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";
@@ -3180,14 +2508,14 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor2.fetch(truncatedPath, newRequest);
-      expect16(response.ok).toBe(true);
+      expect15(response.ok).toBe(true);
       const users = await response.json();
-      expect16(users).toEqual([
+      expect15(users).toEqual([
         { id: 1, name: "Alice" },
         { id: 2, name: "Bob" }
       ]);
     });
-    test16("example fix: should properly forward requests using just Request object", async (c) => {
+    test15("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";
@@ -3196,11 +2524,11 @@ function runRawHttpTests(driverTestConfig) {
         method: "GET"
       });
       const response = await actor2.fetch(newRequest);
-      expect16(response.ok).toBe(true);
+      expect15(response.ok).toBe(true);
       const user = await response.json();
-      expect16(user).toEqual({ id: 1, name: "Alice" });
+      expect15(user).toEqual({ id: 1, name: "Alice" });
     });
-    test16("should support standard fetch API with URL and Request objects", async (c) => {
+    test15("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");
@@ -3209,18 +2537,18 @@ function runRawHttpTests(driverTestConfig) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ from: "URL object" })
       });
-      expect16(urlResponse.ok).toBe(true);
+      expect15(urlResponse.ok).toBe(true);
       const urlData = await urlResponse.json();
-      expect16(urlData).toEqual({ from: "URL object" });
+      expect15(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);
+      expect15(requestResponse.ok).toBe(true);
       const requestData = await requestResponse.json();
-      expect16(requestData).toEqual({ from: "Request object" });
+      expect15(requestData).toEqual({ from: "Request object" });
       const request2 = new Request("http://example.com/api/headers", {
         method: "GET",
         headers: { "X-Original": "request-header" }
@@ -3228,198 +2556,19 @@ function runRawHttpTests(driverTestConfig) {
       const overrideResponse = await actor2.fetch(request2, {
         headers: { "X-Override": "init-header" }
       });
-      expect16(overrideResponse.ok).toBe(true);
+      expect15(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]);
+      expect15(headers["x-override"]).toBe("init-header");
+      expect15(headers["x-original"]).toBe("request-header");
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-http-request-properties.ts
-import { describe as describe19, expect as expect18, test as test18 } from "vitest";
+import { describe as describe17, expect as expect16, test as test16 } from "vitest";
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
-  describe19("raw http request properties", () => {
-    test18("should pass all Request properties correctly to onFetch", async (c) => {
+  describe17("raw http request properties", () => {
+    test16("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", {
@@ -3431,33 +2580,33 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify({ test: "data" })
       });
-      expect18(response.ok).toBe(true);
+      expect16(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({
+      expect16(data.url).toContain("/test/path?foo=bar&baz=qux");
+      expect16(data.pathname).toBe("/test/path");
+      expect16(data.search).toBe("?foo=bar&baz=qux");
+      expect16(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" });
+      expect16(data.method).toBe("POST");
+      expect16(data.headers["content-type"]).toBe("application/json");
+      expect16(data.headers["x-custom-header"]).toBe("custom-value");
+      expect16(data.headers["authorization"]).toBe("Bearer test-token");
+      expect16(data.body).toEqual({ test: "data" });
     });
-    test18("should handle GET requests with no body", async (c) => {
+    test16("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);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.method).toBe("GET");
-      expect18(data.body).toBeNull();
+      expect16(data.method).toBe("GET");
+      expect16(data.body).toBeNull();
     });
-    test18("should handle different content types", async (c) => {
+    test16("should handle different content types", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const formData = new URLSearchParams();
@@ -3470,12 +2619,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: formData.toString()
       });
-      expect18(formResponse.ok).toBe(true);
+      expect16(formResponse.ok).toBe(true);
       const formResult = await formResponse.json();
-      expect18(formResult.headers["content-type"]).toBe(
+      expect16(formResult.headers["content-type"]).toBe(
         "application/x-www-form-urlencoded"
       );
-      expect18(formResult.bodyText).toBe("field1=value1&field2=value2");
+      expect16(formResult.bodyText).toBe("field1=value1&field2=value2");
       const textResponse = await actor2.fetch("test/text", {
         method: "POST",
         headers: {
@@ -3483,12 +2632,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: "Hello, World!"
       });
-      expect18(textResponse.ok).toBe(true);
+      expect16(textResponse.ok).toBe(true);
       const textResult = await textResponse.json();
-      expect18(textResult.headers["content-type"]).toBe("text/plain");
-      expect18(textResult.bodyText).toBe("Hello, World!");
+      expect16(textResult.headers["content-type"]).toBe("text/plain");
+      expect16(textResult.bodyText).toBe("Hello, World!");
     });
-    test18("should preserve all header casing and values", async (c) => {
+    test16("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", {
@@ -3500,34 +2649,34 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           "X-Request-ID": "12345"
         }
       });
-      expect18(response.ok).toBe(true);
+      expect16(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");
+      expect16(data.headers["accept"]).toBe("application/json");
+      expect16(data.headers["accept-language"]).toBe("en-US,en;q=0.9");
+      expect16(data.headers["cache-control"]).toBe("no-cache");
+      expect16(data.headers["user-agent"]).toBeTruthy();
+      expect16(data.headers["x-request-id"]).toBe("12345");
     });
-    test18("should handle empty and special URL paths", async (c) => {
+    test16("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);
+      expect16(rootResponse.ok).toBe(true);
       const rootData = await rootResponse.json();
-      expect18(rootData.pathname).toBe("/");
+      expect16(rootData.pathname).toBe("/");
       const specialResponse = await actor2.fetch(
         "test/path%20with%20spaces/and%2Fslashes"
       );
-      expect18(specialResponse.ok).toBe(true);
+      expect16(specialResponse.ok).toBe(true);
       const specialData = await specialResponse.json();
-      expect18(specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
+      expect16(specialData.pathname).toMatch(/path.*with.*spaces.*and.*slashes/);
       const fragmentResponse = await actor2.fetch("test/path#fragment");
-      expect18(fragmentResponse.ok).toBe(true);
+      expect16(fragmentResponse.ok).toBe(true);
       const fragmentData = await fragmentResponse.json();
-      expect18(fragmentData.pathname).toBe("/test/path");
-      expect18(fragmentData.hash).toBe("");
+      expect16(fragmentData.pathname).toBe("/test/path");
+      expect16(fragmentData.hash).toBe("");
     });
-    test18("should handle request properties for all HTTP methods", async (c) => {
+    test16("should handle request properties for all HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const methods = [
@@ -3546,33 +2695,33 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           body: ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify({ method }) : void 0
         });
         if (method === "HEAD") {
-          expect18(response.status).toBe(200);
+          expect16(response.status).toBe(200);
           const text = await response.text();
-          expect18(text).toBe("");
+          expect16(text).toBe("");
         } else if (method === "OPTIONS") {
-          expect18(response.status).toBe(204);
+          expect16(response.status).toBe(204);
           const text = await response.text();
-          expect18(text).toBe("");
+          expect16(text).toBe("");
         } else {
-          expect18(response.ok).toBe(true);
+          expect16(response.ok).toBe(true);
           const data = await response.json();
-          expect18(data.method).toBe(method);
+          expect16(data.method).toBe(method);
         }
       }
     });
-    test18("should handle complex query parameters", async (c) => {
+    test16("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);
+      expect16(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");
+      expect16(data.searchParams.key).toBe("value2");
+      expect16(data.searchParams["array[]"]).toBe("2");
+      expect16(data.searchParams["nested[prop]"]).toBe("val");
     });
-    test18("should handle multipart form data", async (c) => {
+    test16("should handle multipart form data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const boundary = "----RivetKitBoundary";
@@ -3594,23 +2743,23 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body
       });
-      expect18(response.ok).toBe(true);
+      expect16(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");
+      expect16(data.headers["content-type"]).toContain("multipart/form-data");
+      expect16(data.bodyText).toContain("field1");
+      expect16(data.bodyText).toContain("value1");
     });
-    test18("should handle very long URLs", async (c) => {
+    test16("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);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.searchParams.param).toBe(longValue);
-      expect18(data.search.length).toBeGreaterThan(1e3);
+      expect16(data.searchParams.param).toBe(longValue);
+      expect16(data.search.length).toBeGreaterThan(1e3);
     });
-    test18("should handle large request bodies", async (c) => {
+    test16("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({
@@ -3625,22 +2774,22 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: JSON.stringify(largeArray)
       });
-      expect18(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.body).toHaveLength(1e4);
+      expect16(data.body).toHaveLength(1e4);
     });
-    test18("should handle missing content-type header", async (c) => {
+    test16("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);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.bodyText).toBe("plain text without content-type");
+      expect16(data.bodyText).toBe("plain text without content-type");
     });
-    test18("should handle empty request body", async (c) => {
+    test16("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", {
@@ -3650,12 +2799,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         },
         body: ""
       });
-      expect18(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.body).toBeNull();
-      expect18(data.bodyText).toBe("");
+      expect16(data.body).toBeNull();
+      expect16(data.bodyText).toBe("");
     });
-    test18("should handle custom HTTP methods", async (c) => {
+    test16("should handle custom HTTP methods", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       try {
@@ -3664,12 +2813,12 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
         });
         if (response.ok) {
           const data = await response.json();
-          expect18(data.method).toBe("CUSTOM");
+          expect16(data.method).toBe("CUSTOM");
         }
       } catch (error) {
       }
     });
-    test18("should handle cookies in headers", async (c) => {
+    test16("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", {
@@ -3677,25 +2826,25 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
           Cookie: "session=abc123; user=test; preferences=dark_mode"
         }
       });
-      expect18(response.ok).toBe(true);
+      expect16(response.ok).toBe(true);
       const data = await response.json();
-      expect18(data.headers.cookie).toBe(
+      expect16(data.headers.cookie).toBe(
         "session=abc123; user=test; preferences=dark_mode"
       );
     });
-    test18("should handle URL encoding properly", async (c) => {
+    test16("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);
+      expect16(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");
+      expect16(data.searchParams.special).toBe(" !@#$%^&");
+      expect16(data.searchParams.unicode).toBe("\u2713");
+      expect16(data.searchParams.email).toBe("test@example.com");
     });
-    test18("should handle concurrent requests maintaining separate contexts", async (c) => {
+    test16("should handle concurrent requests maintaining separate contexts", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawHttpRequestPropertiesActor.getOrCreate(["test"]);
       const requests = [
@@ -3717,24 +2866,24 @@ function runRawHttpRequestPropertiesTests(driverTestConfig) {
       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();
+      expect16(results[0].searchParams.id).toBe("1");
+      expect16(results[0].method).toBe("POST");
+      expect16(results[0].body).toEqual({ request: 1 });
+      expect16(results[1].searchParams.id).toBe("2");
+      expect16(results[1].method).toBe("PUT");
+      expect16(results[1].body).toEqual({ request: 2 });
+      expect16(results[2].searchParams.id).toBe("3");
+      expect16(results[2].method).toBe("DELETE");
+      expect16(results[2].body).toBeNull();
     });
   });
 }
 
 // src/driver-test-suite/tests/raw-websocket.ts
-import { describe as describe20, expect as expect19, test as test19 } from "vitest";
+import { describe as describe18, expect as expect17, test as test17 } from "vitest";
 function runRawWebSocketTests(driverTestConfig) {
-  describe20("raw websocket", () => {
-    test19("should establish raw WebSocket connection", async (c) => {
+  describe18("raw websocket", () => {
+    test17("should establish raw WebSocket connection", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
       const ws = await actor2.websocket();
@@ -3761,11 +2910,11 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect19(welcomeMessage.type).toBe("welcome");
-      expect19(welcomeMessage.connectionCount).toBe(1);
+      expect17(welcomeMessage.type).toBe("welcome");
+      expect17(welcomeMessage.connectionCount).toBe(1);
       ws.close();
     });
-    test19("should echo messages", async (c) => {
+    test17("should echo messages", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
       const ws = await actor2.websocket();
@@ -3791,10 +2940,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws.addEventListener("close", reject);
       });
-      expect19(echoMessage).toEqual(testMessage);
+      expect17(echoMessage).toEqual(testMessage);
       ws.close();
     });
-    test19("should handle ping/pong protocol", async (c) => {
+    test17("should handle ping/pong protocol", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
       const ws = await actor2.websocket();
@@ -3818,11 +2967,11 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect19(pongMessage.type).toBe("pong");
-      expect19(pongMessage.timestamp).toBeDefined();
+      expect17(pongMessage.type).toBe("pong");
+      expect17(pongMessage.timestamp).toBeDefined();
       ws.close();
     });
-    test19("should track stats across connections", async (c) => {
+    test17("should track stats across connections", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.websocket();
@@ -3862,15 +3011,15 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       ws1.send(JSON.stringify({ type: "getStats" }));
       const stats = await statsPromise;
-      expect19(stats.connectionCount).toBe(2);
-      expect19(stats.messageCount).toBe(4);
+      expect17(stats.connectionCount).toBe(2);
+      expect17(stats.messageCount).toBe(4);
       const actionStats = await actor1.getStats();
-      expect19(actionStats.connectionCount).toBe(2);
-      expect19(actionStats.messageCount).toBe(4);
+      expect17(actionStats.connectionCount).toBe(2);
+      expect17(actionStats.messageCount).toBe(4);
       ws1.close();
       ws2.close();
     });
-    test19("should handle binary data", async (c) => {
+    test17("should handle binary data", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketBinaryActor.getOrCreate(["binary"]);
       const ws = await actor2.websocket();
@@ -3899,7 +3048,7 @@ function runRawWebSocketTests(driverTestConfig) {
       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]);
+      expect17(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;
@@ -3907,11 +3056,11 @@ function runRawWebSocketTests(driverTestConfig) {
       ws.send(largeData);
       const largeReversed = await receiveBinaryMessage();
       for (let i = 0; i < largeData.length; i++) {
-        expect19(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
+        expect17(largeReversed[i]).toBe(largeData[largeData.length - 1 - i]);
       }
       ws.close();
     });
-    test19("should work with custom paths", async (c) => {
+    test17("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");
@@ -3931,10 +3080,10 @@ function runRawWebSocketTests(driverTestConfig) {
           { once: true }
         );
       });
-      expect19(welcomeMessage.type).toBe("welcome");
+      expect17(welcomeMessage.type).toBe("welcome");
       ws.close();
     });
-    test19("should pass connection parameters through subprotocols", async (c) => {
+    test17("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"], {
@@ -3954,10 +3103,10 @@ function runRawWebSocketTests(driverTestConfig) {
         });
         ws.addEventListener("close", reject);
       });
-      expect19(response).toBeDefined();
+      expect17(response).toBeDefined();
       ws.close();
     });
-    test19("should handle connection close properly", async (c) => {
+    test17("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();
@@ -3968,7 +3117,7 @@ function runRawWebSocketTests(driverTestConfig) {
         });
       }
       const initialStats = await actor2.getStats();
-      expect19(initialStats.connectionCount).toBe(1);
+      expect17(initialStats.connectionCount).toBe(1);
       const closePromise = new Promise((resolve2) => {
         ws.addEventListener("close", () => resolve2(), { once: true });
       });
@@ -3982,9 +3131,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve2) => setTimeout(resolve2, 50));
       }
-      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect17(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test19("should properly handle onWebSocket open and close events", async (c) => {
+    test17("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();
@@ -4002,8 +3151,8 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws1.addEventListener("close", reject);
       });
-      expect19(welcome1.type).toBe("welcome");
-      expect19(welcome1.connectionCount).toBe(1);
+      expect17(welcome1.type).toBe("welcome");
+      expect17(welcome1.connectionCount).toBe(1);
       const ws2 = await actor2.websocket();
       await new Promise((resolve2, reject) => {
         ws2.addEventListener("open", () => resolve2(), { once: true });
@@ -4019,10 +3168,10 @@ function runRawWebSocketTests(driverTestConfig) {
         );
         ws2.addEventListener("close", reject);
       });
-      expect19(welcome2.type).toBe("welcome");
-      expect19(welcome2.connectionCount).toBe(2);
+      expect17(welcome2.type).toBe("welcome");
+      expect17(welcome2.connectionCount).toBe(2);
       const midStats = await actor2.getStats();
-      expect19(midStats.connectionCount).toBe(2);
+      expect17(midStats.connectionCount).toBe(2);
       ws1.close();
       await new Promise((resolve2) => {
         ws1.addEventListener("close", () => resolve2(), { once: true });
@@ -4035,7 +3184,7 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve2) => setTimeout(resolve2, 50));
       }
-      expect19(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
+      expect17(afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
       await new Promise((resolve2) => {
         ws2.addEventListener("close", () => resolve2(), { once: true });
@@ -4048,9 +3197,9 @@ function runRawWebSocketTests(driverTestConfig) {
         }
         await new Promise((resolve2) => setTimeout(resolve2, 50));
       }
-      expect19(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
+      expect17(finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
-    test19("should handle query parameters in websocket paths", async (c) => {
+    test17("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");
@@ -4069,302 +3218,19 @@ function runRawWebSocketTests(driverTestConfig) {
       });
       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);
+      expect17(requestInfo.url).toContain("api/v1/stream");
+      expect17(requestInfo.url).toContain("token=abc123");
+      expect17(requestInfo.url).toContain("user=test");
       ws.close();
     });
   });
 }
 
 // src/driver-test-suite/tests/request-access.ts
-import { describe as describe22, expect as expect21, test as test21 } from "vitest";
+import { describe as describe19, expect as expect18, test as test18 } from "vitest";
 function runRequestAccessTests(driverTestConfig) {
-  describe22("Request Access in Lifecycle Hooks", () => {
-    test21("should have access to request object in onBeforeConnect and createConnState", async (c) => {
+  describe19("Request Access in Lifecycle Hooks", () => {
+    test18("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 }
@@ -4372,19 +3238,19 @@ function runRequestAccessTests(driverTestConfig) {
       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();
+        expect18(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect18(requestInfo.onBeforeConnect.requestUrl).toBeDefined();
+        expect18(requestInfo.onBeforeConnect.requestMethod).toBeDefined();
+        expect18(requestInfo.onBeforeConnect.requestHeaders).toBeDefined();
+        expect18(requestInfo.createConnState.hasRequest).toBe(true);
+        expect18(requestInfo.createConnState.requestUrl).toBeDefined();
+        expect18(requestInfo.createConnState.requestMethod).toBeDefined();
+        expect18(requestInfo.createConnState.requestHeaders).toBeDefined();
       } else {
       }
       await connection.dispose();
     });
-    test21("should not have request when trackRequest is false", async (c) => {
+    test18("should not have request when trackRequest is false", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(
         ["test-no-request"],
@@ -4394,21 +3260,21 @@ function runRequestAccessTests(driverTestConfig) {
       );
       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(
+      expect18(requestInfo.onBeforeConnect.hasRequest).toBe(false);
+      expect18(requestInfo.onBeforeConnect.requestUrl).toBeNull();
+      expect18(requestInfo.onBeforeConnect.requestMethod).toBeNull();
+      expect18(
         Object.keys(requestInfo.onBeforeConnect.requestHeaders)
       ).toHaveLength(0);
-      expect21(requestInfo.createConnState.hasRequest).toBe(false);
-      expect21(requestInfo.createConnState.requestUrl).toBeNull();
-      expect21(requestInfo.createConnState.requestMethod).toBeNull();
-      expect21(
+      expect18(requestInfo.createConnState.hasRequest).toBe(false);
+      expect18(requestInfo.createConnState.requestUrl).toBeNull();
+      expect18(requestInfo.createConnState.requestMethod).toBeNull();
+      expect18(
         Object.keys(requestInfo.createConnState.requestHeaders)
       ).toHaveLength(0);
       await connection.dispose();
     });
-    test21("should capture request headers and method", async (c) => {
+    test18("should capture request headers and method", async (c) => {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const handle = client.requestAccessActor.getOrCreate(["test-headers"], {
         params: { trackRequest: true }
@@ -4416,113 +3282,24 @@ function runRequestAccessTests(driverTestConfig) {
       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(
+        expect18(requestInfo.onBeforeConnect.hasRequest).toBe(true);
+        expect18(requestInfo.onBeforeConnect.requestMethod).toBeTruthy();
+        expect18(requestInfo.onBeforeConnect.requestUrl).toBeTruthy();
+        expect18(requestInfo.onBeforeConnect.requestHeaders).toBeTruthy();
+        expect18(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(
+        expect18(requestInfo.createConnState.hasRequest).toBe(true);
+        expect18(requestInfo.createConnState.requestMethod).toBeTruthy();
+        expect18(requestInfo.createConnState.requestUrl).toBeTruthy();
+        expect18(requestInfo.createConnState.requestHeaders).toBeTruthy();
+        expect18(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);
-          };
-        });
-      }
-    });
   });
 }
 
@@ -4533,11 +3310,11 @@ function runDriverTests(driverTestConfigPartial) {
       ...driverTestConfigPartial,
       clientType
     };
-    describe23(`client type (${clientType})`, () => {
+    describe20(`client type (${clientType})`, () => {
       runActorDriverTests(driverTestConfig);
       runManagerDriverTests(driverTestConfig);
       for (const transport of ["websocket", "sse"]) {
-        describe23(`transport (${transport})`, () => {
+        describe20(`transport (${transport})`, () => {
           runActorConnTests({
             ...driverTestConfig,
             transport
@@ -4553,13 +3330,10 @@ function runDriverTests(driverTestConfigPartial) {
       runActorMetadataTests(driverTestConfig);
       runActorOnStateChangeTests(driverTestConfig);
       runActorErrorHandlingTests(driverTestConfig);
-      runActorAuthTests(driverTestConfig);
       runActorInlineClientTests(driverTestConfig);
       runRawHttpTests(driverTestConfig);
       runRawHttpRequestPropertiesTests(driverTestConfig);
       runRawWebSocketTests(driverTestConfig);
-      runRawHttpDirectRegistryTests(driverTestConfig);
-      runRawWebSocketDirectRegistryTests(driverTestConfig);
       runActorInspectorTests(driverTestConfig);
     });
   }
@@ -4571,46 +3345,64 @@ async function createTestRuntime(registryPath, driverFactory) {
     filepath: registryPath
   });
   registry.config.test.enabled = true;
-  const { driver, cleanup: driverCleanup } = await driverFactory(registry);
-  let injectWebSocket;
-  let upgradeWebSocket;
-  const config = RunConfigSchema.parse({
+  const {
     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
-  };
+    cleanup: driverCleanup,
+    rivetEngine
+  } = await driverFactory(registry);
+  if (rivetEngine) {
+    const cleanup = async () => {
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: rivetEngine.endpoint,
+      namespace: rivetEngine.namespace,
+      runnerName: rivetEngine.runnerName,
+      cleanup
+    };
+  } else {
+    let upgradeWebSocket;
+    const config = RunConfigSchema.parse({
+      driver,
+      getUpgradeWebSocket: () => upgradeWebSocket,
+      inspector: {
+        enabled: true,
+        token: () => "token"
+      }
+    });
+    const managerDriver = driver.manager(registry.config, config);
+    const { router } = createManagerRouter(
+      registry.config,
+      config,
+      managerDriver,
+      false
+    );
+    const nodeWebSocket = createNodeWebSocket({ app: router });
+    upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+    const port = await getPort();
+    const server = honoServe({
+      fetch: router.fetch,
+      hostname: "127.0.0.1",
+      port
+    });
+    invariant(
+      nodeWebSocket.injectWebSocket !== void 0,
+      "should have injectWebSocket"
+    );
+    nodeWebSocket.injectWebSocket(server);
+    const serverEndpoint = `http://127.0.0.1:${port}`;
+    logger().info({ msg: "test serer listening", port });
+    const cleanup = async () => {
+      await new Promise((resolve2) => server.close(() => resolve2(void 0)));
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: serverEndpoint,
+      namespace: "default",
+      runnerName: "rivetkit",
+      cleanup
+    };
+  }
 }
 export {
   createTestRuntime,