rivetkit 2.0.3 → 2.0.5

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

@@ -1,44 +1,38 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunkFCCPJNMAcjs = require('../chunk-FCCPJNMA.cjs');
+var _chunkFGFT4FVXcjs = require('../chunk-FGFT4FVX.cjs');
 
 
+var _chunkD7NWUCRKcjs = require('../chunk-D7NWUCRK.cjs');
 
 
-var _chunkUIM22YJLcjs = require('../chunk-UIM22YJL.cjs');
 
 
 
-var _chunkKUPQZYUQcjs = require('../chunk-KUPQZYUQ.cjs');
+var _chunkMRZS2J4Xcjs = require('../chunk-MRZS2J4X.cjs');
 
 
-var _chunkURVFQMYIcjs = require('../chunk-URVFQMYI.cjs');
 
+var _chunkLZIBTLEYcjs = require('../chunk-LZIBTLEY.cjs');
 
 
-var _chunkO2MBYIXOcjs = require('../chunk-O2MBYIXO.cjs');
-require('../chunk-R2OPSKIV.cjs');
+var _chunkPHSQJ6QIcjs = require('../chunk-PHSQJ6QI.cjs');
 
 
-var _chunkTZJKSBUQcjs = require('../chunk-TZJKSBUQ.cjs');
+var _chunkRM2SVURRcjs = require('../chunk-RM2SVURR.cjs');
 
 
-var _chunkCTBOSFUHcjs = require('../chunk-CTBOSFUH.cjs');
-require('../chunk-UBUC5C3G.cjs');
 
 
+var _chunkIRMBWX36cjs = require('../chunk-IRMBWX36.cjs');
 
 
+var _chunk5YTI25C3cjs = require('../chunk-5YTI25C3.cjs');
+require('../chunk-WADSS5X4.cjs');
 
-var _chunk6WKQDDUDcjs = require('../chunk-6WKQDDUD.cjs');
 
 
-var _chunk2CRLFV6Zcjs = require('../chunk-2CRLFV6Z.cjs');
-require('../chunk-OGAPU3UG.cjs');
-
-
-
-var _chunkGIR3AFFIcjs = require('../chunk-GIR3AFFI.cjs');
+var _chunk5QGQK44Lcjs = require('../chunk-5QGQK44L.cjs');
 
 // src/driver-test-suite/mod.ts
 var _nodeserver = require('@hono/node-server');
@@ -47,168 +41,75 @@ var _bundlerequire = require('bundle-require');
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
 var _vitest = require('vitest');
 
+// src/driver-test-suite/log.ts
+function logger() {
+  return _chunk5YTI25C3cjs.getLogger.call(void 0, "test-suite");
+}
+
 // 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);
-}
-
-// src/driver-test-suite/test-inline-client-driver.ts
-function createTestInlineClientDriver(endpoint, transport) {
+function createTestInlineClientDriver(endpoint, encoding, transport) {
   return {
-    action: async (_c, actorQuery, encoding, params, name, args) => {
-      return makeInlineRequest(
-        endpoint,
-        encoding,
-        transport,
-        "action",
-        [void 0, actorQuery, encoding, params, name, args]
-      );
+    getForId(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "getForId", [
+        input
+      ]);
+    },
+    getWithKey(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "getWithKey", [
+        input
+      ]);
     },
-    resolveActorId: async (_c, actorQuery, encodingKind, params) => {
+    getOrCreateWithKey(input) {
       return makeInlineRequest(
         endpoint,
-        encodingKind,
+        encoding,
         transport,
-        "resolveActorId",
-        [void 0, actorQuery, encodingKind, params]
+        "getOrCreateWithKey",
+        [input]
       );
     },
-    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"
+    createActor(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "createActor", [
+        input
       ]);
-      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) => {
+    async sendRequest(actorId, actorRequest) {
       var _a;
-      logger().debug("sending http message via test inline driver", {
+      const oldUrl = new URL(actorRequest.url);
+      const normalizedPath = oldUrl.pathname.startsWith("/") ? oldUrl.pathname.slice(1) : oldUrl.pathname;
+      const pathWithQuery = normalizedPath + oldUrl.search;
+      logger().debug({
+        msg: "sending raw http request via test inline driver",
         actorId,
         encoding,
-        connectionId,
-        transport
+        path: pathWithQuery
       });
-      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
-            ]
-          })
-        }
+      const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
+      logger().debug({ msg: "rewriting http url", from: oldUrl, to: url });
+      const headers = new Headers(actorRequest.headers);
+      headers.set(_chunkIRMBWX36cjs.HEADER_ACTOR_ID, actorId);
+      const response = await fetch(
+        new Request(url, {
+          method: actorRequest.method,
+          headers,
+          body: actorRequest.body,
+          signal: actorRequest.signal
+        })
       );
-      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)(
+              throw new (0, _chunkMRZS2J4Xcjs.ActorError)(
                 errorData.error.code,
                 errorData.error.message,
                 errorData.error.metadata
@@ -216,7 +117,7 @@ function createTestInlineClientDriver(endpoint, transport) {
             }
           }
         } catch (e) {
-          if (!(e instanceof _chunkO2MBYIXOcjs.ActorError)) {
+          if (!(e instanceof _chunkMRZS2J4Xcjs.ActorError)) {
             return response;
           }
           throw e;
@@ -224,70 +125,375 @@ function createTestInlineClientDriver(endpoint, transport) {
       }
       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, );
+    async openWebSocket(path, actorId, encoding2, params) {
+      const WebSocket2 = await _chunkPHSQJ6QIcjs.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
-        }
-      );
+      logger().debug({
+        msg: "creating websocket connection via test inline driver"
+      });
       const wsUrl = new URL(
-        `${endpoint}/registry/.test/inline-driver/raw-websocket`
+        `${endpoint}/.test/inline-driver/connect-websocket/ws`
       );
-      wsUrl.searchParams.set("actorQuery", JSON.stringify(actorQuery));
+      wsUrl.searchParams.set("path", normalizedPath);
+      wsUrl.searchParams.set("actorId", actorId);
       if (params !== void 0)
         wsUrl.searchParams.set("params", JSON.stringify(params));
-      wsUrl.searchParams.set("encodingKind", encoding);
-      wsUrl.searchParams.set("path", normalizedPath);
-      if (protocols !== void 0)
-        wsUrl.searchParams.set("protocols", JSON.stringify(protocols));
+      wsUrl.searchParams.set("encodingKind", encoding2);
       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
-      });
+      logger().debug({ msg: "connecting to websocket", url: 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 proxyRequest(c, actorRequest, actorId) {
+      return await this.sendRequest(actorId, actorRequest);
+    },
+    proxyWebSocket(_c, _path, _actorId, _encoding, _params, _authData) {
+      throw "UNIMPLEMENTED";
+    },
+    displayInformation() {
+      return { name: "Test Inline", properties: {} };
     }
+    // action: async <Args extends Array<unknown> = unknown[], Response = unknown>(
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encoding: Encoding,
+    // 	params: unknown,
+    // 	name: string,
+    // 	args: Args,
+    // ): Promise<Response> => {
+    // 	return makeInlineRequest<Response>(
+    // 		endpoint,
+    // 		encoding,
+    // 		transport,
+    // 		"action",
+    // 		[undefined, actorQuery, encoding, params, name, args],
+    // 	);
+    // },
+    //
+    // resolveActorId: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encodingKind: Encoding,
+    // 	params: unknown,
+    // ): Promise<string> => {
+    // 	return makeInlineRequest<string>(
+    // 		endpoint,
+    // 		encodingKind,
+    // 		transport,
+    // 		"resolveActorId",
+    // 		[undefined, actorQuery, encodingKind, params],
+    // 	);
+    // },
+    //
+    // connectWebSocket: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encodingKind: Encoding,
+    // 	params: unknown,
+    // ): Promise<WebSocket> => {
+    // 	const WebSocket = await importWebSocket();
+    //
+    // 	logger().debug({
+    // 		msg: "creating websocket connection via test inline driver",
+    // 		actorQuery,
+    // 		encodingKind,
+    // 	});
+    //
+    // 	// Create WebSocket connection to the test endpoint
+    // 	const wsUrl = new URL(
+    // 		`${endpoint}/registry/.test/inline-driver/connect-websocket`,
+    // 	);
+    // 	wsUrl.searchParams.set("actorQuery", JSON.stringify(actorQuery));
+    // 	if (params !== undefined)
+    // 		wsUrl.searchParams.set("params", JSON.stringify(params));
+    // 	wsUrl.searchParams.set("encodingKind", encodingKind);
+    //
+    // 	// Convert http/https to ws/wss
+    // 	const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+    // 	const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+    //
+    // 	logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
+    //
+    // 	// Create and return the WebSocket
+    // 	// Node & browser WebSocket types are incompatible
+    // 	const ws = new WebSocket(finalWsUrl, [
+    // 		// HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+    // 		"rivetkit",
+    // 	]) as any;
+    //
+    // 	return ws;
+    // },
+    //
+    // connectSse: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encodingKind: Encoding,
+    // 	params: unknown,
+    // ): Promise<UniversalEventSource> => {
+    // 	logger().debug({
+    // 		msg: "creating sse connection via test inline driver",
+    // 		actorQuery,
+    // 		encodingKind,
+    // 		params,
+    // 	});
+    //
+    // 	// Dynamically import EventSource if needed
+    // 	const EventSourceImport = await import("eventsource");
+    // 	// Handle both ES modules (default) and CommonJS export patterns
+    // 	const EventSourceConstructor =
+    // 		(EventSourceImport as any).default || EventSourceImport;
+    //
+    // 	// Encode parameters for the URL
+    // 	const actorQueryParam = encodeURIComponent(JSON.stringify(actorQuery));
+    // 	const encodingParam = encodeURIComponent(encodingKind);
+    // 	const paramsParam = params
+    // 		? encodeURIComponent(JSON.stringify(params))
+    // 		: null;
+    //
+    // 	// Create SSE connection URL
+    // 	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({ msg: "connecting to sse", url: sseUrl.toString() });
+    //
+    // 	// Create and return the EventSource
+    // 	const eventSource = new EventSourceConstructor(sseUrl.toString());
+    //
+    // 	// Wait for the connection to be established before returning
+    // 	await new Promise<void>((resolve, reject) => {
+    // 		eventSource.onopen = () => {
+    // 			logger().debug({ msg: "sse connection established" });
+    // 			resolve();
+    // 		};
+    //
+    // 		eventSource.onerror = (event: Event) => {
+    // 			logger().error({ msg: "sse connection failed", event });
+    // 			reject(new Error("Failed to establish SSE connection"));
+    // 		};
+    //
+    // 		// Set a timeout in case the connection never establishes
+    // 		setTimeout(() => {
+    // 			if (eventSource.readyState !== EventSourceConstructor.OPEN) {
+    // 				reject(new Error("SSE connection timed out"));
+    // 			}
+    // 		}, 10000); // 10 second timeout
+    // 	});
+    //
+    // 	return eventSource as UniversalEventSource;
+    // },
+    //
+    // sendHttpMessage: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorId: string,
+    // 	encoding: Encoding,
+    // 	connectionId: string,
+    // 	connectionToken: string,
+    // 	message: protocol.ToServer,
+    // ): Promise<void> => {
+    // 	logger().debug({
+    // 		msg: "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: [
+    // 					undefined,
+    // 					actorId,
+    // 					encoding,
+    // 					connectionId,
+    // 					connectionToken,
+    // 					message,
+    // 				],
+    // 			} satisfies TestInlineDriverCallRequest),
+    // 		},
+    // 	);
+    //
+    // 	if (!result.ok) {
+    // 		throw new Error(`Failed to send HTTP message: ${result.statusText}`);
+    // 	}
+    //
+    // 	// Discard response
+    // 	await result.body?.cancel();
+    // },
+    //
+    // rawHttpRequest: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encoding: Encoding,
+    // 	params: unknown,
+    // 	path: string,
+    // 	init: RequestInit,
+    // ): Promise<Response> => {
+    // 	// Normalize path to match other drivers
+    // 	const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    //
+    // 	logger().debug({
+    // 		msg: "sending raw http request via test inline driver",
+    // 		actorQuery,
+    // 		encoding,
+    // 		path: normalizedPath,
+    // 	});
+    //
+    // 	// Use the dedicated raw HTTP endpoint
+    // 	const url = `${endpoint}/registry/.test/inline-driver/raw-http/${normalizedPath}`;
+    //
+    // 	logger().debug({ msg: "rewriting http url", from: path, to: url });
+    //
+    // 	// Merge headers with our metadata
+    // 	const headers = new Headers(init.headers);
+    // 	headers.set(HEADER_ACTOR_QUERY, JSON.stringify(actorQuery));
+    // 	headers.set(HEADER_ENCODING, encoding);
+    // 	if (params !== undefined) {
+    // 		headers.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+    // 	}
+    //
+    // 	// Forward the request directly
+    // 	const response = await fetch(url, {
+    // 		...init,
+    // 		headers,
+    // 	});
+    //
+    // 	// Check if it's an error response from our handler
+    // 	if (
+    // 		!response.ok &&
+    // 		response.headers.get("content-type")?.includes("application/json")
+    // 	) {
+    // 		try {
+    // 			// Clone the response to avoid consuming the body
+    // 			const clonedResponse = response.clone();
+    // 			const errorData = (await clonedResponse.json()) as any;
+    // 			if (errorData.error) {
+    // 				// Handle both error formats:
+    // 				// 1. { error: { code, message, metadata } } - structured format
+    // 				// 2. { error: "message" } - simple string format (from custom onFetch handlers)
+    // 				if (typeof errorData.error === "object") {
+    // 					throw new ClientActorError(
+    // 						errorData.error.code,
+    // 						errorData.error.message,
+    // 						errorData.error.metadata,
+    // 					);
+    // 				}
+    // 				// For simple string errors, just return the response as-is
+    // 				// This allows custom onFetch handlers to return their own error formats
+    // 			}
+    // 		} catch (e) {
+    // 			// If it's not our error format, just return the response as-is
+    // 			if (!(e instanceof ClientActorError)) {
+    // 				return response;
+    // 			}
+    // 			throw e;
+    // 		}
+    // 	}
+    //
+    // 	return response;
+    // },
+    //
+    // rawWebSocket: async (
+    // 	_c: HonoContext | undefined,
+    // 	actorQuery: ActorQuery,
+    // 	encoding: Encoding,
+    // 	params: unknown,
+    // 	path: string,
+    // 	protocols: string | string[] | undefined,
+    // ): Promise<WebSocket> => {
+    // 	logger().debug({ msg: "test inline driver rawWebSocket called" });
+    // 	const WebSocket = await importWebSocket();
+    //
+    // 	// Normalize path to match other drivers
+    // 	const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    //
+    // 	logger().debug({
+    // 		msg: "creating raw websocket connection via test inline driver",
+    // 		actorQuery,
+    // 		encoding,
+    // 		path: normalizedPath,
+    // 		protocols,
+    // 	});
+    //
+    // 	// Create WebSocket connection to the test endpoint
+    // 	const wsUrl = new URL(
+    // 		`${endpoint}/registry/.test/inline-driver/raw-websocket`,
+    // 	);
+    // 	wsUrl.searchParams.set("actorQuery", JSON.stringify(actorQuery));
+    // 	if (params !== undefined)
+    // 		wsUrl.searchParams.set("params", JSON.stringify(params));
+    // 	wsUrl.searchParams.set("encodingKind", encoding);
+    // 	wsUrl.searchParams.set("path", normalizedPath);
+    // 	if (protocols !== undefined)
+    // 		wsUrl.searchParams.set("protocols", JSON.stringify(protocols));
+    //
+    // 	// Convert http/https to ws/wss
+    // 	const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+    // 	const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+    //
+    // 	logger().debug({ msg: "connecting to raw websocket", url: finalWsUrl });
+    //
+    // 	logger().debug({
+    // 		msg: "rewriting websocket url",
+    // 		from: path,
+    // 		to: finalWsUrl,
+    // 	});
+    //
+    // 	// Create and return the WebSocket
+    // 	// Node & browser WebSocket types are incompatible
+    // 	const ws = new WebSocket(finalWsUrl, [
+    // 		// HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+    // 		"rivetkit",
+    // 	]) as any;
+    //
+    // 	logger().debug({
+    // 		msg: "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", {
+  logger().debug({
+    msg: "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
-      })
-    }
-  );
+  const response = await fetch(`${endpoint}/.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}`);
   }
@@ -298,13 +504,14 @@ async function makeInlineRequest(endpoint, encoding, transport, method, args) {
   if ("ok" in callResponse) {
     return callResponse.ok;
   } else if ("err" in callResponse) {
-    throw new (0, _chunkO2MBYIXOcjs.ActorError)(
+    throw new (0, _chunkMRZS2J4Xcjs.ActorError)(
+      callResponse.err.group,
       callResponse.err.code,
       callResponse.err.message,
       callResponse.err.metadata
     );
   } else {
-    _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, callResponse);
+    _chunkIRMBWX36cjs.assertUnreachable.call(void 0, callResponse);
   }
 }
 
@@ -315,22 +522,25 @@ async function setupDriverTest(c, driverTestConfig) {
     _vitest.vi.useFakeTimers();
     _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();
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunkURVFQMYIcjs.createClient.call(void 0, endpoint, {
+    client = _chunkD7NWUCRKcjs.createClient.call(void 0, {
+      endpoint,
+      namespace,
+      runnerName,
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
-    const clientDriver = createTestInlineClientDriver(
+    const managerDriver = createTestInlineClientDriver(
       endpoint,
+      "bare",
       _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"))
     );
-    client = _chunkO2MBYIXOcjs.createClientWithDriver.call(void 0, clientDriver);
+    client = _chunkMRZS2J4Xcjs.createClientWithDriver.call(void 0, managerDriver);
   } else {
-    _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkIRMBWX36cjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -342,7 +552,7 @@ async function setupDriverTest(c, driverTestConfig) {
 }
 async function waitFor(driverTestConfig, ms) {
   if (driverTestConfig.useRealTimers) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   } else {
     _vitest.vi.advanceTimersByTime(ms);
     return Promise.resolve();
@@ -430,432 +640,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) {
@@ -904,11 +688,11 @@ function runActorConnTests(driverTestConfig) {
         const handle = client.counter.getOrCreate(["test-mixed-rpc-ws"]);
         const connection = handle.connect();
         const receivedEvents = [];
-        const receivedEventsPromise = new Promise((resolve2) => {
+        const receivedEventsPromise = new Promise((resolve) => {
           connection.on("newCount", (count) => {
             receivedEvents.push(count);
             if (receivedEvents.includes(1) && receivedEvents.includes(6) && receivedEvents.includes(9))
-              resolve2(void 0);
+              resolve(void 0);
           });
         });
         await connection.increment(1);
@@ -1287,9 +1071,7 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 500;
-var sleep = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleep = _chunkMRZS2J4Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1315,9 +1097,7 @@ var sleep = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithLongRpc = _chunkMRZS2J4Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -1346,9 +1126,7 @@ var sleepWithLongRpc = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithRawHttp = _chunkMRZS2J4Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1361,8 +1139,8 @@ 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 });
-      await new Promise((resolve2) => setTimeout(resolve2, duration));
+      c.log.info({ msg: "starting long fetch request", duration });
+      await new Promise((resolve) => setTimeout(resolve, duration));
       c.log.info("finished long fetch request");
       return new Response(JSON.stringify({ completed: true }), {
         headers: { "Content-Type": "application/json" }
@@ -1383,9 +1161,7 @@ var sleepWithRawHttp = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithRawWebSocket = _chunkMRZS2J4Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1395,7 +1171,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 +1198,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 +1224,7 @@ var sleepWithRawWebSocket = _chunkUIM22YJLcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunkUIM22YJLcjs.actor.call(void 0, {
-  onAuth: () => {
-  },
+var sleepWithNoSleepOption = _chunkMRZS2J4Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -1605,7 +1381,7 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       const waitPromise = new Promise(
-        (resolve2) => sleepActor.once("waiting", resolve2)
+        (resolve) => sleepActor.once("waiting", resolve)
       );
       const longRunningPromise = sleepActor.longRunningRpc();
       await waitPromise;
@@ -1638,32 +1414,32 @@ function runActorSleepTests(driverTestConfig) {
         _vitest.expect.call(void 0, startCount).toBe(1);
       }
       const ws = await sleepActor.websocket();
-      await new Promise((resolve2, reject) => {
-        ws.onopen = () => resolve2();
+      await new Promise((resolve, reject) => {
+        ws.onopen = () => resolve();
         ws.onerror = reject;
       });
-      await new Promise((resolve2) => {
+      await new Promise((resolve) => {
         ws.onmessage = (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "connected") {
-            resolve2();
+            resolve();
           }
         };
       });
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       ws.send(JSON.stringify({ type: "getCounts" }));
-      const counts = await new Promise((resolve2) => {
+      const counts = await new Promise((resolve) => {
         ws.onmessage = (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "counts") {
-            resolve2(data);
+            resolve(data);
           }
         };
       });
       _vitest.expect.call(void 0, counts.sleepCount).toBe(0);
       _vitest.expect.call(void 0, counts.startCount).toBe(1);
       ws.close();
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve) => setTimeout(resolve, 100));
       await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
       {
         const { startCount, sleepCount } = await sleepActor.getCounts();
@@ -1816,15 +1592,8 @@ function runActorErrorHandlingTests(driverTestConfig) {
           await handle.throwInternalError();
           _vitest.expect.call(void 0, true).toBe(false);
         } catch (error) {
-          if (driverTestConfig.clientType === "http") {
-            _vitest.expect.call(void 0, error.code).toBe(_chunkGIR3AFFIcjs.INTERNAL_ERROR_CODE);
-            _vitest.expect.call(void 0, error.message).toBe(_chunkGIR3AFFIcjs.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.message).toBe("This is an internal error");
-          } else {
-            _chunk6WKQDDUDcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
-          }
+          _vitest.expect.call(void 0, error.code).toBe(_chunk5QGQK44Lcjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunk5QGQK44Lcjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -1919,6 +1688,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) => {
@@ -2139,11 +1931,11 @@ function runActorInlineClientTests(driverTestConfig) {
 // src/driver-test-suite/tests/actor-inspector.ts
 
 function runActorInspectorTests(driverTestConfig) {
-  _vitest.describe.call(void 0, "Actor Inspector Tests", () => {
+  _vitest.describe.skip("Actor Inspector Tests", () => {
     _vitest.describe.call(void 0, "Manager Inspector", () => {
       _vitest.test.call(void 0, "should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2157,7 +1949,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2180,7 +1972,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2205,7 +1997,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2217,7 +2009,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2241,7 +2033,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2259,7 +2051,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2273,7 +2065,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2289,7 +2081,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 = _chunkLZIBTLEYcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -2311,10 +2103,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2326,10 +2118,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2344,10 +2136,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2366,10 +2158,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2391,10 +2183,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2425,10 +2217,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2450,10 +2242,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2476,10 +2268,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2504,10 +2296,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2525,10 +2317,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2549,10 +2341,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 = _chunkLZIBTLEYcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunk6WKQDDUDcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkIRMBWX36cjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2801,7 +2593,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 +2608,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 +2856,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 +3030,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", () => {
@@ -3738,24 +3353,24 @@ function runRawWebSocketTests(driverTestConfig) {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["basic"]);
       const ws = await actor2.websocket();
-      await new Promise((resolve2) => {
+      await new Promise((resolve) => {
         if (ws.readyState === WebSocket.OPEN) {
-          resolve2();
+          resolve();
         } else {
           ws.addEventListener(
             "open",
             () => {
-              resolve2();
+              resolve();
             },
             { once: true }
           );
         }
       });
-      const welcomeMessage = await new Promise((resolve2, reject) => {
+      const welcomeMessage = await new Promise((resolve, reject) => {
         ws.addEventListener(
           "message",
           (event) => {
-            resolve2(JSON.parse(event.data));
+            resolve(JSON.parse(event.data));
           },
           { once: true }
         );
@@ -3770,22 +3385,22 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor2 = client.rawWebSocketActor.getOrCreate(["echo"]);
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
-        await new Promise((resolve2, reject) => {
-          ws.addEventListener("open", () => resolve2(), { once: true });
+        await new Promise((resolve, reject) => {
+          ws.addEventListener("open", () => resolve(), { once: true });
           ws.addEventListener("close", reject);
         });
       }
-      await new Promise((resolve2, reject) => {
-        ws.addEventListener("message", () => resolve2(), { once: true });
+      await new Promise((resolve, reject) => {
+        ws.addEventListener("message", () => resolve(), { once: true });
         ws.addEventListener("close", reject);
       });
       const testMessage = { test: "data", timestamp: Date.now() };
       ws.send(JSON.stringify(testMessage));
-      const echoMessage = await new Promise((resolve2, reject) => {
+      const echoMessage = await new Promise((resolve, reject) => {
         ws.addEventListener(
           "message",
           (event) => {
-            resolve2(JSON.parse(event.data));
+            resolve(JSON.parse(event.data));
           },
           { once: true }
         );
@@ -3799,21 +3414,21 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor2 = client.rawWebSocketActor.getOrCreate(["ping"]);
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
-        await new Promise((resolve2, reject) => {
-          ws.addEventListener("open", () => resolve2(), { once: true });
+        await new Promise((resolve, reject) => {
+          ws.addEventListener("open", () => resolve(), { once: true });
           ws.addEventListener("close", reject);
         });
       }
-      await new Promise((resolve2, reject) => {
-        ws.addEventListener("message", () => resolve2(), { once: true });
+      await new Promise((resolve, reject) => {
+        ws.addEventListener("message", () => resolve(), { once: true });
         ws.addEventListener("close", reject);
       });
       ws.send(JSON.stringify({ type: "ping" }));
-      const pongMessage = await new Promise((resolve2, reject) => {
+      const pongMessage = await new Promise((resolve, reject) => {
         ws.addEventListener("message", (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "pong") {
-            resolve2(data);
+            resolve(data);
           }
         });
         ws.addEventListener("close", reject);
@@ -3826,23 +3441,23 @@ function runRawWebSocketTests(driverTestConfig) {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor1 = client.rawWebSocketActor.getOrCreate(["stats"]);
       const ws1 = await actor1.websocket();
-      const ws1MessagePromise = new Promise((resolve2, reject) => {
-        ws1.addEventListener("message", () => resolve2(), { once: true });
+      const ws1MessagePromise = new Promise((resolve, reject) => {
+        ws1.addEventListener("message", () => resolve(), { once: true });
         ws1.addEventListener("close", reject);
       });
       await ws1MessagePromise;
       const actor2 = client.rawWebSocketActor.get(["stats"]);
       const ws2 = await actor2.websocket();
-      const ws2MessagePromise = new Promise((resolve2, reject) => {
-        ws2.addEventListener("message", () => resolve2(), { once: true });
+      const ws2MessagePromise = new Promise((resolve, reject) => {
+        ws2.addEventListener("message", () => resolve(), { once: true });
         ws2.addEventListener("close", reject);
       });
       await Promise.all([ws1MessagePromise, ws2MessagePromise]);
-      const pingPromise = new Promise((resolve2, reject) => {
+      const pingPromise = new Promise((resolve, reject) => {
         ws2.addEventListener("message", (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "pong") {
-            resolve2(void 0);
+            resolve(void 0);
           }
         });
         ws2.addEventListener("close", reject);
@@ -3851,11 +3466,11 @@ function runRawWebSocketTests(driverTestConfig) {
       ws1.send(JSON.stringify({ data: "test3" }));
       ws2.send(JSON.stringify({ type: "ping" }));
       await pingPromise;
-      const statsPromise = new Promise((resolve2, reject) => {
+      const statsPromise = new Promise((resolve, reject) => {
         ws1.addEventListener("message", (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "stats") {
-            resolve2(data);
+            resolve(data);
           }
         });
         ws1.addEventListener("close", reject);
@@ -3875,18 +3490,18 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor2 = client.rawWebSocketBinaryActor.getOrCreate(["binary"]);
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
-        await new Promise((resolve2, reject) => {
-          ws.addEventListener("open", () => resolve2(), { once: true });
+        await new Promise((resolve, reject) => {
+          ws.addEventListener("open", () => resolve(), { once: true });
           ws.addEventListener("close", reject);
         });
       }
       const receiveBinaryMessage = async () => {
         const response = await new Promise(
-          (resolve2, reject) => {
+          (resolve, reject) => {
             ws.addEventListener(
               "message",
               (event) => {
-                resolve2(event.data);
+                resolve(event.data);
               },
               { once: true }
             );
@@ -3915,18 +3530,18 @@ function runRawWebSocketTests(driverTestConfig) {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["paths"]);
       const ws = await actor2.websocket("custom/path");
-      await new Promise((resolve2, reject) => {
+      await new Promise((resolve, reject) => {
         ws.addEventListener("open", () => {
-          resolve2();
+          resolve();
         });
         ws.addEventListener("error", reject);
         ws.addEventListener("close", reject);
       });
-      const welcomeMessage = await new Promise((resolve2) => {
+      const welcomeMessage = await new Promise((resolve) => {
         ws.addEventListener(
           "message",
           (event) => {
-            resolve2(JSON.parse(event.data));
+            resolve(JSON.parse(event.data));
           },
           { once: true }
         );
@@ -3941,15 +3556,15 @@ function runRawWebSocketTests(driverTestConfig) {
         params: testParams
       });
       const ws = await actor2.websocket();
-      await new Promise((resolve2) => {
-        ws.addEventListener("open", () => resolve2(), { once: true });
+      await new Promise((resolve) => {
+        ws.addEventListener("open", () => resolve(), { once: true });
       });
       ws.send(JSON.stringify({ type: "getAuthData" }));
-      const response = await new Promise((resolve2, reject) => {
+      const response = await new Promise((resolve, reject) => {
         ws.addEventListener("message", (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "authData") {
-            resolve2(data);
+            resolve(data);
           }
         });
         ws.addEventListener("close", reject);
@@ -3962,15 +3577,15 @@ function runRawWebSocketTests(driverTestConfig) {
       const actor2 = client.rawWebSocketActor.getOrCreate(["close-test"]);
       const ws = await actor2.websocket();
       if (ws.readyState !== WebSocket.OPEN) {
-        await new Promise((resolve2, reject) => {
-          ws.addEventListener("open", () => resolve2(), { once: true });
+        await new Promise((resolve, reject) => {
+          ws.addEventListener("open", () => resolve(), { once: true });
           ws.addEventListener("close", reject);
         });
       }
       const initialStats = await actor2.getStats();
       _vitest.expect.call(void 0, initialStats.connectionCount).toBe(1);
-      const closePromise = new Promise((resolve2) => {
-        ws.addEventListener("close", () => resolve2(), { once: true });
+      const closePromise = new Promise((resolve) => {
+        ws.addEventListener("close", () => resolve(), { once: true });
       });
       ws.close();
       await closePromise;
@@ -3980,7 +3595,7 @@ function runRawWebSocketTests(driverTestConfig) {
         if (finalStats.connectionCount === 0) {
           break;
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 50));
+        await new Promise((resolve) => setTimeout(resolve, 50));
       }
       _vitest.expect.call(void 0, finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
@@ -3988,15 +3603,15 @@ function runRawWebSocketTests(driverTestConfig) {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["open-close-test"]);
       const ws1 = await actor2.websocket();
-      await new Promise((resolve2, reject) => {
-        ws1.addEventListener("open", () => resolve2(), { once: true });
+      await new Promise((resolve, reject) => {
+        ws1.addEventListener("open", () => resolve(), { once: true });
         ws1.addEventListener("close", reject);
       });
-      const welcome1 = await new Promise((resolve2, reject) => {
+      const welcome1 = await new Promise((resolve, reject) => {
         ws1.addEventListener(
           "message",
           (event) => {
-            resolve2(JSON.parse(event.data));
+            resolve(JSON.parse(event.data));
           },
           { once: true }
         );
@@ -4005,15 +3620,15 @@ function runRawWebSocketTests(driverTestConfig) {
       _vitest.expect.call(void 0, welcome1.type).toBe("welcome");
       _vitest.expect.call(void 0, welcome1.connectionCount).toBe(1);
       const ws2 = await actor2.websocket();
-      await new Promise((resolve2, reject) => {
-        ws2.addEventListener("open", () => resolve2(), { once: true });
+      await new Promise((resolve, reject) => {
+        ws2.addEventListener("open", () => resolve(), { once: true });
         ws2.addEventListener("close", reject);
       });
-      const welcome2 = await new Promise((resolve2, reject) => {
+      const welcome2 = await new Promise((resolve, reject) => {
         ws2.addEventListener(
           "message",
           (event) => {
-            resolve2(JSON.parse(event.data));
+            resolve(JSON.parse(event.data));
           },
           { once: true }
         );
@@ -4024,8 +3639,8 @@ function runRawWebSocketTests(driverTestConfig) {
       const midStats = await actor2.getStats();
       _vitest.expect.call(void 0, midStats.connectionCount).toBe(2);
       ws1.close();
-      await new Promise((resolve2) => {
-        ws1.addEventListener("close", () => resolve2(), { once: true });
+      await new Promise((resolve) => {
+        ws1.addEventListener("close", () => resolve(), { once: true });
       });
       let afterFirstClose;
       for (let i = 0; i < 20; i++) {
@@ -4033,12 +3648,12 @@ function runRawWebSocketTests(driverTestConfig) {
         if (afterFirstClose.connectionCount === 1) {
           break;
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 50));
+        await new Promise((resolve) => setTimeout(resolve, 50));
       }
       _vitest.expect.call(void 0, afterFirstClose == null ? void 0 : afterFirstClose.connectionCount).toBe(1);
       ws2.close();
-      await new Promise((resolve2) => {
-        ws2.addEventListener("close", () => resolve2(), { once: true });
+      await new Promise((resolve) => {
+        ws2.addEventListener("close", () => resolve(), { once: true });
       });
       let finalStats;
       for (let i = 0; i < 20; i++) {
@@ -4046,7 +3661,7 @@ function runRawWebSocketTests(driverTestConfig) {
         if (finalStats.connectionCount === 0) {
           break;
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 50));
+        await new Promise((resolve) => setTimeout(resolve, 50));
       }
       _vitest.expect.call(void 0, finalStats == null ? void 0 : finalStats.connectionCount).toBe(0);
     });
@@ -4054,15 +3669,15 @@ function runRawWebSocketTests(driverTestConfig) {
       const { client } = await setupDriverTest(c, driverTestConfig);
       const actor2 = client.rawWebSocketActor.getOrCreate(["query-params"]);
       const ws = await actor2.websocket("api/v1/stream?token=abc123&user=test");
-      await new Promise((resolve2, reject) => {
-        ws.addEventListener("open", () => resolve2(), { once: true });
+      await new Promise((resolve, reject) => {
+        ws.addEventListener("open", () => resolve(), { once: true });
         ws.addEventListener("error", reject);
       });
-      const requestInfoPromise = new Promise((resolve2, reject) => {
+      const requestInfoPromise = new Promise((resolve, reject) => {
         ws.addEventListener("message", (event) => {
           const data = JSON.parse(event.data);
           if (data.type === "requestInfo") {
-            resolve2(data);
+            resolve(data);
           }
         });
         ws.addEventListener("close", reject);
@@ -4077,289 +3692,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 +3766,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 +3796,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 +3811,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 = _chunkRM2SVURRcjs.RunConfigSchema.parse({
+      driver,
+      getUpgradeWebSocket: () => upgradeWebSocket,
+      inspector: {
+        enabled: true,
+        token: () => "token"
+      }
+    });
+    const managerDriver = driver.manager(registry.config, config);
+    const { router } = _chunkMRZS2J4Xcjs.createManagerRouter.call(void 0, 
+      registry.config,
+      config,
+      managerDriver,
+      false
+    );
+    const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
+    upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+    const port = await _chunkFGFT4FVXcjs.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((resolve) => server.close(() => resolve(void 0)));
+      await (driverCleanup == null ? void 0 : driverCleanup());
+    };
+    return {
+      endpoint: serverEndpoint,
+      namespace: "default",
+      runnerName: "rivetkit",
+      cleanup
+    };
+  }
 }