rivetkit 2.0.3 → 2.0.4

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

@@ -1,44 +1,33 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _chunkFCCPJNMAcjs = require('../chunk-FCCPJNMA.cjs');
+var _chunkIH6CKNDWcjs = require('../chunk-IH6CKNDW.cjs');
 
 
+var _chunk4R73YDN3cjs = require('../chunk-4R73YDN3.cjs');
 
 
-var _chunkUIM22YJLcjs = require('../chunk-UIM22YJL.cjs');
 
+var _chunkVO7ZRVVDcjs = require('../chunk-VO7ZRVVD.cjs');
 
 
-var _chunkKUPQZYUQcjs = require('../chunk-KUPQZYUQ.cjs');
 
+var _chunkLWNKVZG5cjs = require('../chunk-LWNKVZG5.cjs');
+require('../chunk-QNNXFOQV.cjs');
 
-var _chunkURVFQMYIcjs = require('../chunk-URVFQMYI.cjs');
 
+var _chunkWHBPJNGWcjs = require('../chunk-WHBPJNGW.cjs');
 
 
-var _chunkO2MBYIXOcjs = require('../chunk-O2MBYIXO.cjs');
-require('../chunk-R2OPSKIV.cjs');
 
+var _chunkGICQ3YCUcjs = require('../chunk-GICQ3YCU.cjs');
 
-var _chunkTZJKSBUQcjs = require('../chunk-TZJKSBUQ.cjs');
 
+var _chunk4CXBCT26cjs = require('../chunk-4CXBCT26.cjs');
+require('../chunk-6LJT3QRL.cjs');
 
-var _chunkCTBOSFUHcjs = require('../chunk-CTBOSFUH.cjs');
-require('../chunk-UBUC5C3G.cjs');
 
 
-
-
-
-var _chunk6WKQDDUDcjs = require('../chunk-6WKQDDUD.cjs');
-
-
-var _chunk2CRLFV6Zcjs = require('../chunk-2CRLFV6Z.cjs');
-require('../chunk-OGAPU3UG.cjs');
-
-
-
-var _chunkGIR3AFFIcjs = require('../chunk-GIR3AFFI.cjs');
+var _chunkSBHHJ6QScjs = require('../chunk-SBHHJ6QS.cjs');
 
 // src/driver-test-suite/mod.ts
 var _nodeserver = require('@hono/node-server');
@@ -47,268 +36,17 @@ var _bundlerequire = require('bundle-require');
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
 var _vitest = require('vitest');
 
-// src/driver-test-suite/tests/action-features.ts
-
-
-// src/driver-test-suite/utils.ts
-var _path = require('path');
-
-
-// src/driver-test-suite/test-inline-client-driver.ts
-var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
-
 // src/driver-test-suite/log.ts
-var LOGGER_NAME = "test-suite";
 function logger() {
-  return _chunk2CRLFV6Zcjs.getLogger.call(void 0, LOGGER_NAME);
+  return _chunk4CXBCT26cjs.getLogger.call(void 0, "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 _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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 Promise.resolve().then(() => _interopRequireWildcard(require("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(_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY, JSON.stringify(actorQuery));
-      headers.set(_chunk6WKQDDUDcjs.HEADER_ENCODING, encoding);
-      if (params !== void 0) {
-        headers.set(_chunk6WKQDDUDcjs.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 (0, _chunkO2MBYIXOcjs.ActorError)(
-                errorData.error.code,
-                errorData.error.message,
-                errorData.error.metadata
-              );
-            }
-          }
-        } catch (e) {
-          if (!(e instanceof _chunkO2MBYIXOcjs.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 _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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 (0, _chunkO2MBYIXOcjs.ActorError)(
-      callResponse.err.code,
-      callResponse.err.message,
-      callResponse.err.metadata
-    );
-  } else {
-    _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, callResponse);
-  }
-}
+// src/driver-test-suite/tests/action-features.ts
+
 
 // src/driver-test-suite/utils.ts
+var _path = require('path');
+
 var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
 async function setupDriverTest(c, driverTestConfig) {
   if (!driverTestConfig.useRealTimers) {
@@ -316,21 +54,20 @@ async function setupDriverTest(c, driverTestConfig) {
     _vitest.vi.setSystemTime(FAKE_TIME);
   }
   const projectPath = _path.resolve.call(void 0, __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 = _chunkURVFQMYIcjs.createClient.call(void 0, endpoint, {
+    client = _chunk4R73YDN3cjs.createClient.call(void 0, {
+      endpoint,
+      namespace,
+      runnerName,
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
-    const clientDriver = createTestInlineClientDriver(
-      endpoint,
-      _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"))
-    );
-    client = _chunkO2MBYIXOcjs.createClientWithDriver.call(void 0, clientDriver);
+    throw "TODO";
   } else {
-    _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -430,432 +167,6 @@ function runActionFeaturesTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/actor-auth.ts
-
-function runActorAuthTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "Actor Authentication Tests", () => {
-    _vitest.describe.call(void 0, "Basic Authentication", () => {
-      _vitest.test.call(void 0, "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") {
-          _vitest.expect.call(void 0, authData).toBeUndefined();
-        } else {
-          _vitest.expect.call(void 0, authData).toEqual({
-            userId: "user123",
-            token: "valid-api-key"
-          });
-        }
-        const requests = await instance.getRequests();
-        _vitest.expect.call(void 0, requests).toBe(1);
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, typeof requests).toBe("number");
-        } else {
-          try {
-            await instance.getRequests();
-            _vitest.expect.fail("Expected authentication error");
-          } catch (error) {
-            _vitest.expect.call(void 0, error.code).toBe("missing_auth");
-          }
-        }
-      });
-      _vitest.test.call(void 0, "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") {
-          _vitest.expect.call(void 0, authData).toBeUndefined();
-        } else {
-          _vitest.expect.call(void 0, authData).toBeDefined();
-          _vitest.expect.call(void 0, authData.userId).toBe("user123");
-          _vitest.expect.call(void 0, authData.token).toBe("valid-api-key");
-        }
-      });
-    });
-    _vitest.describe.call(void 0, "Intent-Based Authentication", () => {
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, value).toBe(0);
-        } else {
-          const instance = client.intentAuthActor.getForId(actorId, {
-            params: { role: "user" }
-            // Actions require user or admin role
-          });
-          const value = await instance.getValue();
-          _vitest.expect.call(void 0, value).toBe(0);
-        }
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, value).toBe(0);
-        } else {
-          try {
-            const instance = client.intentAuthActor.getOrCreate(void 0, {
-              params: { role: "user" }
-            });
-            await instance.getValue();
-            _vitest.expect.fail("Expected permission error for create operation");
-          } catch (error) {
-            _vitest.expect.call(void 0, error.code).toBe("insufficient_permissions");
-            _vitest.expect.call(void 0, error.message).toContain(
-              "Admin role required"
-            );
-          }
-        }
-      });
-      _vitest.test.call(void 0, "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);
-          _vitest.expect.call(void 0, result).toBe(42);
-        } else {
-          try {
-            await instance.setValue(42);
-            _vitest.expect.fail("Expected permission error for action");
-          } catch (error) {
-            _vitest.expect.call(void 0, error.code).toBe("insufficient_permissions");
-            _vitest.expect.call(void 0, error.message).toContain(
-              "User or admin role required"
-            );
-          }
-        }
-      });
-    });
-    _vitest.describe.call(void 0, "Public Access", () => {
-      _vitest.test.call(void 0, "should allow access with empty onAuth", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const instance = client.publicActor.getOrCreate();
-        const visitors = await instance.visit();
-        _vitest.expect.call(void 0, visitors).toBe(1);
-        const visitors2 = await instance.visit();
-        _vitest.expect.call(void 0, visitors2).toBe(2);
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, value).toBe(42);
-        } else {
-          try {
-            await instance.getValue();
-            _vitest.expect.fail(
-              "Expected access to be denied for actor without onAuth"
-            );
-          } catch (error) {
-            _vitest.expect.call(void 0, error.code).toBe("forbidden");
-          }
-        }
-      });
-    });
-    _vitest.describe.call(void 0, "Async Authentication", () => {
-      _vitest.test.call(void 0, "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();
-        _vitest.expect.call(void 0, result).toBe(1);
-        const authData = await instance.getAuthData();
-        if (driverTestConfig.clientType === "inline") {
-          _vitest.expect.call(void 0, authData).toBeUndefined();
-        } else {
-          _vitest.expect.call(void 0, authData).toBeDefined();
-          _vitest.expect.call(void 0, authData.userId).toBe("user-valid");
-          _vitest.expect.call(void 0, authData.validated).toBe(true);
-        }
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, result).toBe(1);
-        } else {
-          try {
-            await instance.increment();
-            _vitest.expect.fail("Expected async auth failure");
-          } catch (error) {
-            _vitest.expect.call(void 0, error.code).toBe("missing_token");
-          }
-        }
-      });
-    });
-    _vitest.describe.call(void 0, "Authentication Across Transports", () => {
-      if (driverTestConfig.transport === "websocket") {
-        _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, authData).toBeDefined();
-          _vitest.expect.call(void 0, authData.userId).toBe("user123");
-        });
-      }
-      _vitest.test.call(void 0, "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();
-        _vitest.expect.call(void 0, typeof requests).toBe("number");
-      });
-    });
-    _vitest.describe.call(void 0, "Error Handling", () => {
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, typeof requests).toBe("number");
-        } else {
-          try {
-            await instance.getRequests();
-            _vitest.expect.fail("Expected authentication error");
-          } catch (error) {
-            const actorError = error;
-            _vitest.expect.call(void 0, actorError.code).toBeDefined();
-            _vitest.expect.call(void 0, actorError.message).toBeDefined();
-          }
-        }
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.call(void 0, result).toBe(1);
-        } else {
-          try {
-            await instance.increment();
-            _vitest.expect.fail("Expected token error");
-          } catch (error) {
-            const actorError = error;
-            _vitest.expect.call(void 0, actorError.code).toBe("missing_token");
-            _vitest.expect.call(void 0, actorError.message).toBe("Token required");
-          }
-        }
-      });
-    });
-    _vitest.describe.call(void 0, "Raw HTTP Authentication", () => {
-      _vitest.test.call(void 0, "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");
-        _vitest.expect.call(void 0, response.ok).toBe(true);
-        const data = await response.json();
-        _vitest.expect.call(void 0, data.message).toBe("Authenticated request");
-        _vitest.expect.call(void 0, data.requestCount).toBe(1);
-        const count = await instance.getRequestCount();
-        _vitest.expect.call(void 0, count).toBe(1);
-      });
-      _vitest.test.call(void 0, "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") {
-          _vitest.expect.call(void 0, response.ok).toBe(true);
-          _vitest.expect.call(void 0, response.status).toBe(200);
-        } else {
-          _vitest.expect.call(void 0, response.ok).toBe(false);
-          _vitest.expect.call(void 0, response.status).toBe(400);
-        }
-        try {
-          const errorData = await response.json();
-          _vitest.expect.call(void 0, errorData.c || errorData.code).toBe("missing_auth");
-        } catch (e2) {
-        }
-      });
-      _vitest.test.call(void 0, "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") {
-          _vitest.expect.call(void 0, response.ok).toBe(true);
-          _vitest.expect.call(void 0, response.status).toBe(200);
-        } else {
-          _vitest.expect.call(void 0, response.ok).toBe(false);
-          _vitest.expect.call(void 0, response.status).toBe(403);
-        }
-        try {
-          const errorData = await response.json();
-          _vitest.expect.call(void 0, errorData.c || errorData.code).toBe("forbidden");
-        } catch (e3) {
-        }
-      });
-      _vitest.test.call(void 0, "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");
-        _vitest.expect.call(void 0, response.ok).toBe(true);
-        const data = await response.json();
-        _vitest.expect.call(void 0, data.message).toBe("Welcome visitor!");
-        _vitest.expect.call(void 0, data.count).toBe(1);
-        const response2 = await instance.fetch("api/visit");
-        const data2 = await response2.json();
-        _vitest.expect.call(void 0, data2.count).toBe(2);
-      });
-      _vitest.test.call(void 0, "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");
-        _vitest.expect.call(void 0, response1.ok).toBe(false);
-        _vitest.expect.call(void 0, response1.status).toBe(401);
-        const error1 = await response1.json();
-        _vitest.expect.call(void 0, error1.error).toBe("Unauthorized");
-        const response2 = await instance.fetch("api/data", {
-          headers: {
-            Authorization: "Bearer wrong-token"
-          }
-        });
-        _vitest.expect.call(void 0, response2.ok).toBe(false);
-        _vitest.expect.call(void 0, response2.status).toBe(403);
-        const response3 = await instance.fetch("api/data", {
-          headers: {
-            Authorization: "Bearer custom-token"
-          }
-        });
-        _vitest.expect.call(void 0, response3.ok).toBe(true);
-        const data = await response3.json();
-        _vitest.expect.call(void 0, data.message).toBe("Authorized!");
-        _vitest.expect.call(void 0, data.authorized).toBe(1);
-        const stats = await instance.getStats();
-        _vitest.expect.call(void 0, stats.authorized).toBe(1);
-        _vitest.expect.call(void 0, stats.unauthorized).toBe(2);
-      });
-    });
-    _vitest.describe.call(void 0, "Raw WebSocket Authentication", () => {
-      _vitest.test.call(void 0, "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;
-        _vitest.expect.call(void 0, welcomeData.message).toBe("Authenticated WebSocket connection");
-        _vitest.expect.call(void 0, welcomeData.connectionCount).toBe(1);
-        ws.close();
-      });
-      _vitest.test.call(void 0, "should deny raw WebSocket access without auth", async (c) => {
-        const { client } = await setupDriverTest(c, driverTestConfig);
-        const instance = client.rawWebSocketAuthActor.getOrCreate();
-        try {
-          await instance.websocket();
-          _vitest.expect.fail("Expected authentication error");
-        } catch (error) {
-          _vitest.expect.call(void 0, error).toBeDefined();
-        }
-      });
-      _vitest.test.call(void 0, "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();
-          _vitest.expect.fail("Expected forbidden error");
-        } catch (error) {
-          _vitest.expect.call(void 0, error).toBeDefined();
-        }
-      });
-      _vitest.test.call(void 0, "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;
-        _vitest.expect.call(void 0, welcomeData.message).toBe("Public WebSocket connection");
-        _vitest.expect.call(void 0, welcomeData.visitorNumber).toBe(1);
-        ws.close();
-      });
-      _vitest.test.call(void 0, "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;
-          _vitest.expect.call(void 0, errorData.type).toBe("error");
-          _vitest.expect.call(void 0, errorData.message).toBe("Unauthorized");
-        } catch (error) {
-          _vitest.expect.call(void 0, 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;
-        _vitest.expect.call(void 0, authData.message).toBe("Welcome authenticated user!");
-        ws2.close();
-        const stats = await instance.getStats();
-        _vitest.expect.call(void 0, stats.authorized).toBeGreaterThanOrEqual(1);
-        _vitest.expect.call(void 0, stats.unauthorized).toBeGreaterThanOrEqual(1);
-      });
-    });
-  });
-}
-
 // src/driver-test-suite/tests/actor-conn.ts
 
 function runActorConnTests(driverTestConfig) {
@@ -1287,9 +598,7 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 500;
-var sleep = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleep = _chunkVO7ZRVVDcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1315,9 +624,7 @@ var sleep = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithLongRpc = _chunkVO7ZRVVDcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -1346,9 +653,7 @@ var sleepWithLongRpc = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithRawHttp = _chunkVO7ZRVVDcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1361,7 +666,7 @@ var sleepWithRawHttp = _chunkUIM22YJLcjs.actor.call(void 0, {
     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 }), {
@@ -1383,9 +688,7 @@ var sleepWithRawHttp = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithRawWebSocket = _chunkVO7ZRVVDcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1395,7 +698,8 @@ var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
   },
   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(
@@ -1421,14 +725,15 @@ var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
           } else if (parsed.type === "keepAlive") {
             websocket.send(JSON.stringify({ type: "ack" }));
           }
-        } catch (e4) {
+        } catch (e2) {
           websocket.send(data);
         }
       }
     });
     websocket.addEventListener("close", () => {
       c.state.connectionCount -= 1;
-      c.log.info("websocket disconnected", {
+      c.log.info({
+        msg: "websocket disconnected",
         connectionCount: c.state.connectionCount
       });
     });
@@ -1446,9 +751,7 @@ var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithNoSleepOption = _chunkVO7ZRVVDcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1817,13 +1120,13 @@ function runActorErrorHandlingTests(driverTestConfig) {
           _vitest.expect.call(void 0, true).toBe(false);
         } catch (error) {
           if (driverTestConfig.clientType === "http") {
-            _vitest.expect.call(void 0, error.code).toBe(_chunkGIR3AFFIcjs.INTERNAL_ERROR_CODE);
-            _vitest.expect.call(void 0, error.message).toBe(_chunkGIR3AFFIcjs.INTERNAL_ERROR_DESCRIPTION);
+            _vitest.expect.call(void 0, error.code).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
+            _vitest.expect.call(void 0, error.message).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_DESCRIPTION);
           } else if (driverTestConfig.clientType === "inline") {
-            _vitest.expect.call(void 0, error.code).toBe(_chunkGIR3AFFIcjs.INTERNAL_ERROR_CODE);
+            _vitest.expect.call(void 0, error.code).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
             _vitest.expect.call(void 0, error.message).toBe("This is an internal error");
           } else {
-            _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+            _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
           }
         }
       });
@@ -1919,6 +1222,29 @@ function runActorHandleTests(driverTestConfig) {
         const retrievedCount = await handle.getCount();
         _vitest.expect.call(void 0, retrievedCount).toBe(9);
       });
+      _vitest.test.call(void 0, "errors when calling create twice with the same key", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const key = ["duplicate-create-handle", crypto.randomUUID()];
+        await client.counter.create(key);
+        try {
+          await client.counter.create(key);
+          _vitest.expect.fail("did not error on duplicate create");
+        } catch (err) {
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("already_exists");
+        }
+      });
+      _vitest.test.call(void 0, ".get().resolve() errors for non-existent actor", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const missingId = `nonexistent-${crypto.randomUUID()}`;
+        try {
+          await client.counter.get([missingId]).resolve();
+          _vitest.expect.fail("did not error for get().resolve() on missing actor");
+        } catch (err) {
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
+        }
+      });
     });
     _vitest.describe.call(void 0, "Action Functionality", () => {
       _vitest.test.call(void 0, "should call actions directly on the handle", async (c) => {
@@ -2143,7 +1469,7 @@ function runActorInspectorTests(driverTestConfig) {
     _vitest.describe.call(void 0, "Manager Inspector", () => {
       _vitest.test.call(void 0, "should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2157,7 +1483,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         await client.counter.create(["test-actor-1"]);
         await client.counter.create(["test-actor-2"]);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2180,7 +1506,7 @@ function runActorInspectorTests(driverTestConfig) {
         const actorKey2 = ["test-cursor-2"];
         await client.counter.create(actorKey1);
         await client.counter.create(actorKey2);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2205,7 +1531,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2217,7 +1543,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2241,7 +1567,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2259,7 +1585,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-get-by-id"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2273,7 +1599,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should return 404 for non-existent actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2289,7 +1615,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2311,10 +1637,10 @@ function runActorInspectorTests(driverTestConfig) {
       _vitest.test.call(void 0, "should handle actor not found", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
         const actorId = "non-existing";
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2326,10 +1652,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-ping"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2344,10 +1670,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state"]);
         const actorId = await handle.resolve();
         await handle.increment(5);
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2366,10 +1692,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-state-replace"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2391,10 +1717,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state-patch"]);
         const actorId = await handle.resolve();
         await handle.increment(3);
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2425,10 +1751,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2450,10 +1776,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2476,10 +1802,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2504,10 +1830,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-rpcs"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2525,10 +1851,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-db"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2549,10 +1875,10 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-db-query"]);
         const actorId = await handle.resolve();
-        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2801,7 +2127,8 @@ function runManagerDriverTests(driverTestConfig) {
           await client.counter.create(uniqueKey);
           _vitest.expect.fail("did not error on duplicate create");
         } catch (err) {
-          _vitest.expect.call(void 0, err.code).toBe("actor_already_exists");
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("already_exists");
         }
         const count = await counter.increment(0);
         _vitest.expect.call(void 0, count).toBe(5);
@@ -2815,7 +2142,8 @@ function runManagerDriverTests(driverTestConfig) {
           await client.counter.get([nonexistentId]).resolve();
           _vitest.expect.fail("did not error for get");
         } catch (err) {
-          _vitest.expect.call(void 0, err.code).toBe("actor_not_found");
+          _vitest.expect.call(void 0, err.group).toBe("actor");
+          _vitest.expect.call(void 0, err.code).toBe("not_found");
         }
         const createdCounter = client.counter.getOrCreate(nonexistentId);
         await createdCounter.increment(3);
@@ -3062,7 +2390,7 @@ function runRawHttpTests(driverTestConfig) {
         _vitest.expect.call(void 0, errorData.message).toContain(
           "onFetch handler must return a Response"
         );
-      } catch (e5) {
+      } catch (e3) {
       }
     });
     _vitest.test.call(void 0, "should handle different HTTP methods", async (c) => {
@@ -3236,186 +2564,7 @@ function runRawHttpTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/raw-http-direct-registry.ts
-
-function runRawHttpDirectRegistryTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "raw http - direct registry access", () => {
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery)
-          }
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      _vitest.expect.call(void 0, response.status).toBe(200);
-      const data = await response.json();
-      _vitest.expect.call(void 0, data).toEqual({ message: "Hello from actor!" });
-    });
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(testData)
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      _vitest.expect.call(void 0, response.status).toBe(200);
-      const data = await response.json();
-      _vitest.expect.call(void 0, data).toEqual(testData);
-    });
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-            ...customHeaders
-          }
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      const headers = await response.json();
-      _vitest.expect.call(void 0, headers["x-custom-header"]).toBe("direct-test-value");
-      _vitest.expect.call(void 0, headers["x-another-header"]).toBe("another-direct-value");
-    });
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-            [_chunk6WKQDDUDcjs.HEADER_CONN_PARAMS]: JSON.stringify(connParams)
-          }
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      const data = await response.json();
-      _vitest.expect.call(void 0, data).toEqual({ message: "Hello from actor!" });
-    });
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery)
-          }
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(false);
-      _vitest.expect.call(void 0, response.status).toBe(404);
-    });
-    _vitest.test.call(void 0, "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: {
-              [_chunk6WKQDDUDcjs.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") {
-          _vitest.expect.call(void 0, response.ok).toBe(true);
-          const data = await response.json();
-          _vitest.expect.call(void 0, data).toEqual({ method });
-        } else {
-          _vitest.expect.call(void 0, response.status).toBe(404);
-        }
-      }
-    });
-    _vitest.test.call(void 0, "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: {
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
-            "Content-Type": "application/octet-stream"
-          },
-          body: binaryData
-        }
-      );
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      const responseBuffer = await response.arrayBuffer();
-      const responseArray = new Uint8Array(responseBuffer);
-      _vitest.expect.call(void 0, Array.from(responseArray)).toEqual([1, 2, 3, 4, 5]);
-    });
-  });
-}
-
-// src/driver-test-suite/tests/raw-http-request-properties.ts
+// src/driver-test-suite/tests/raw-http-request-properties.ts
 
 function runRawHttpRequestPropertiesTests(driverTestConfig) {
   _vitest.describe.call(void 0, "raw http request properties", () => {
@@ -4077,289 +3226,6 @@ function runRawWebSocketTests(driverTestConfig) {
   });
 }
 
-// src/driver-test-suite/tests/raw-websocket-direct-registry.ts
-
-function runRawWebSocketDirectRegistryTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "raw websocket - direct registry access", () => {
-    _vitest.test.call(void 0, "should establish vanilla WebSocket connection with proper subprotocols", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-      });
-      _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
-      _vitest.expect.call(void 0, welcomeMessage.connectionCount).toBe(1);
-      ws.close();
-    });
-    _vitest.test.call(void 0, "should echo messages with vanilla WebSocket", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-      });
-      _vitest.expect.call(void 0, echoMessage).toEqual(testMessage);
-      ws.close();
-    });
-    _vitest.test.call(void 0, "should handle connection parameters for authentication", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-      });
-      _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
-      ws.close();
-    });
-    _vitest.test.call(void 0, "should handle custom user protocols alongside rivetkit protocols", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-      });
-      _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
-      ws.close();
-    });
-    _vitest.test.call(void 0, "should handle different paths for WebSocket routes", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-        });
-        _vitest.expect.call(void 0, welcomeMessage.type).toBe("welcome");
-        ws.close();
-      }
-    });
-    _vitest.test.call(void 0, "should return error for actors without onWebSocket handler", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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 });
-      });
-      _vitest.expect.call(void 0, ws.readyState).toBe(ws.CLOSED || 3);
-    });
-    _vitest.test.call(void 0, "should handle binary data over vanilla WebSocket", async (c) => {
-      const { endpoint } = await setupDriverTest(c, driverTestConfig);
-      const WebSocket2 = await _chunkTZJKSBUQcjs.importWebSocket.call(void 0, );
-      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);
-      _vitest.expect.call(void 0, 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);
-      });
-      _vitest.expect.call(void 0, echoMessage.type).toBe("binary-test");
-      _vitest.expect.call(void 0, echoMessage.size).toBe(5);
-      ws.close();
-    });
-  });
-}
-
 // src/driver-test-suite/tests/request-access.ts
 
 function runRequestAccessTests(driverTestConfig) {
@@ -4434,95 +3300,6 @@ function runRequestAccessTests(driverTestConfig) {
       }
       await connection.dispose();
     });
-    _vitest.test.call(void 0, "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");
-      }
-    });
-    _vitest.test.call(void 0, "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
-        );
-      }
-      _vitest.expect.call(void 0, response.ok).toBe(true);
-      const data = await response.json();
-      _vitest.expect.call(void 0, data.hasRequest).toBe(true);
-      _vitest.expect.call(void 0, data.requestUrl).toContain("/test-path");
-      _vitest.expect.call(void 0, data.requestMethod).toBe("POST");
-      _vitest.expect.call(void 0, data.requestHeaders).toBeDefined();
-      _vitest.expect.call(void 0, data.requestHeaders["content-type"]).toBe(
-        "application/json"
-      );
-      _vitest.expect.call(void 0, data.requestHeaders["x-test-header"]).toBe("test-value");
-    });
-    _vitest.test.call(void 0, "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);
-              _vitest.expect.call(void 0, data.hasRequest).toBe(true);
-              _vitest.expect.call(void 0, data.requestUrl).toContain("/test-path");
-              _vitest.expect.call(void 0, data.requestMethod).toBe("GET");
-              _vitest.expect.call(void 0, data.requestHeaders).toBeDefined();
-              ws.close();
-              resolve2();
-            } catch (error) {
-              reject(error);
-            }
-          };
-          ws.onerror = (error) => {
-            reject(error);
-          };
-        });
-      }
-    });
   });
 }
 
@@ -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 = _chunkCTBOSFUHcjs.RunConfigSchema.parse({
+  const {
     driver,
-    getUpgradeWebSocket: () => upgradeWebSocket,
-    inspector: {
-      enabled: true,
-      token: () => "token"
-    }
-  });
-  const managerDriver = driver.manager(registry.config, config);
-  const inlineDriver = _chunkUIM22YJLcjs.createInlineClientDriver.call(void 0, managerDriver);
-  const { router } = _chunkUIM22YJLcjs.createManagerRouter.call(void 0, 
-    registry.config,
-    config,
-    inlineDriver,
-    managerDriver,
-    false
-  );
-  const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
-  upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-  injectWebSocket = nodeWebSocket.injectWebSocket;
-  const port = await _chunkFCCPJNMAcjs.getPort.call(void 0, );
-  const server = _nodeserver.serve.call(void 0, {
-    fetch: router.fetch,
-    hostname: "127.0.0.1",
-    port
-  });
-  _invariant2.default.call(void 0, 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 = _chunkWHBPJNGWcjs.RunConfigSchema.parse({
+      driver,
+      getUpgradeWebSocket: () => upgradeWebSocket,
+      inspector: {
+        enabled: true,
+        token: () => "token"
+      }
+    });
+    const managerDriver = driver.manager(registry.config, config);
+    const { router } = _chunkVO7ZRVVDcjs.createManagerRouter.call(void 0, 
+      registry.config,
+      config,
+      managerDriver,
+      false
+    );
+    const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
+    upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+    const port = await _chunkIH6CKNDWcjs.getPort.call(void 0, );
+    const server = _nodeserver.serve.call(void 0, {
+      fetch: router.fetch,
+      hostname: "127.0.0.1",
+      port
+    });
+    _invariant2.default.call(void 0, 
+      nodeWebSocket.injectWebSocket !== void 0,
+      "should have injectWebSocket"
+    );
+    nodeWebSocket.injectWebSocket(server);
+    const serverEndpoint = `http://127.0.0.1:${port}`;
+    logger().info({ msg: "test serer listening", port });
+    const cleanup = async () => {
+      await new Promise((resolve2) => server.close(() => resolve2(void 0)));
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: serverEndpoint,
+      namespace: "default",
+      runnerName: "rivetkit",
+      cleanup
+    };
+  }
 }