rivetkit 2.0.4 → 2.0.6

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

@@ -1,33 +1,41 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+"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 _chunkIH6CKNDWcjs = require('../chunk-IH6CKNDW.cjs');
+var _chunk6P6RA47Ncjs = require('../chunk-6P6RA47N.cjs');
 
 
-var _chunk4R73YDN3cjs = require('../chunk-4R73YDN3.cjs');
 
+var _chunkTWGATZ3Xcjs = require('../chunk-TWGATZ3X.cjs');
 
 
-var _chunkVO7ZRVVDcjs = require('../chunk-VO7ZRVVD.cjs');
 
+var _chunkKUPQZYUQcjs = require('../chunk-KUPQZYUQ.cjs');
 
 
-var _chunkLWNKVZG5cjs = require('../chunk-LWNKVZG5.cjs');
-require('../chunk-QNNXFOQV.cjs');
+var _chunkUTI5NCEScjs = require('../chunk-UTI5NCES.cjs');
 
 
-var _chunkWHBPJNGWcjs = require('../chunk-WHBPJNGW.cjs');
 
+var _chunkUFWAK3X2cjs = require('../chunk-UFWAK3X2.cjs');
+require('../chunk-DIAYNQTE.cjs');
 
 
-var _chunkGICQ3YCUcjs = require('../chunk-GICQ3YCU.cjs');
+var _chunkKG3C7MKRcjs = require('../chunk-KG3C7MKR.cjs');
 
 
-var _chunk4CXBCT26cjs = require('../chunk-4CXBCT26.cjs');
-require('../chunk-6LJT3QRL.cjs');
+var _chunkNTCUGYSDcjs = require('../chunk-NTCUGYSD.cjs');
 
 
 
-var _chunkSBHHJ6QScjs = require('../chunk-SBHHJ6QS.cjs');
+
+var _chunkTCUI5JFEcjs = require('../chunk-TCUI5JFE.cjs');
+
+
+var _chunkMRRT2CZDcjs = require('../chunk-MRRT2CZD.cjs');
+require('../chunk-5JBFVV4C.cjs');
+
+
+
+var _chunk5QGQK44Lcjs = require('../chunk-5QGQK44L.cjs');
 
 // src/driver-test-suite/mod.ts
 var _nodeserver = require('@hono/node-server');
@@ -38,36 +46,509 @@ var _vitest = require('vitest');
 
 // src/driver-test-suite/log.ts
 function logger() {
-  return _chunk4CXBCT26cjs.getLogger.call(void 0, "test-suite");
+  return _chunkMRRT2CZDcjs.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);
+function createTestInlineClientDriver(endpoint, encoding, transport) {
+  return {
+    getForId(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "getForId", [
+        input
+      ]);
+    },
+    getWithKey(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "getWithKey", [
+        input
+      ]);
+    },
+    getOrCreateWithKey(input) {
+      return makeInlineRequest(
+        endpoint,
+        encoding,
+        transport,
+        "getOrCreateWithKey",
+        [input]
+      );
+    },
+    createActor(input) {
+      return makeInlineRequest(endpoint, encoding, transport, "createActor", [
+        input
+      ]);
+    },
+    async sendRequest(actorId, actorRequest) {
+      var _a;
+      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,
+        path: pathWithQuery
+      });
+      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(_chunkTCUI5JFEcjs.HEADER_ACTOR_ID, actorId);
+      const response = await fetch(
+        new Request(url, {
+          method: actorRequest.method,
+          headers,
+          body: actorRequest.body,
+          signal: actorRequest.signal
+        })
+      );
+      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, _chunkUFWAK3X2cjs.ActorError)(
+                errorData.error.code,
+                errorData.error.message,
+                errorData.error.metadata
+              );
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof _chunkUFWAK3X2cjs.ActorError)) {
+            return response;
+          }
+          throw e;
+        }
+      }
+      return response;
+    },
+    async openWebSocket(path, actorId, encoding2, params) {
+      const WebSocket2 = await _chunkKG3C7MKRcjs.importWebSocket.call(void 0, );
+      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+      logger().debug({
+        msg: "creating websocket connection via test inline driver"
+      });
+      const wsUrl = new URL(
+        `${endpoint}/.test/inline-driver/connect-websocket/ws`
+      );
+      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", encoding2);
+      const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+      const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+      logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
+      const ws = new WebSocket2(finalWsUrl, [
+        // HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
+        "rivetkit"
+      ]);
+      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({
+    msg: "sending inline request",
+    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}`);
+  }
+  const buffer = await response.arrayBuffer();
+  const callResponse = cbor.decode(
+    new Uint8Array(buffer)
+  );
+  if ("ok" in callResponse) {
+    return callResponse.ok;
+  } else if ("err" in callResponse) {
+    throw new (0, _chunkUFWAK3X2cjs.ActorError)(
+      callResponse.err.group,
+      callResponse.err.code,
+      callResponse.err.message,
+      callResponse.err.metadata
+    );
+  } else {
+    _chunkTCUI5JFEcjs.assertUnreachable.call(void 0, callResponse);
+  }
+}
+
+// src/driver-test-suite/utils.ts
 var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
 async function setupDriverTest(c, driverTestConfig) {
   if (!driverTestConfig.useRealTimers) {
     _vitest.vi.useFakeTimers();
     _vitest.vi.setSystemTime(FAKE_TIME);
   }
-  const projectPath = _path.resolve.call(void 0, __dirname, "../../fixtures/driver-test-suite");
-  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start(projectPath);
+  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
-    client = _chunk4R73YDN3cjs.createClient.call(void 0, {
+    client = _chunkUTI5NCEScjs.createClient.call(void 0, {
       endpoint,
       namespace,
       runnerName,
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
-    throw "TODO";
+    const managerDriver = createTestInlineClientDriver(
+      endpoint,
+      "bare",
+      _nullishCoalesce(driverTestConfig.transport, () => ( "websocket"))
+    );
+    _invariant2.default.call(void 0, driverTestConfig.transport, "missing transport");
+    const runConfig = _chunkNTCUGYSDcjs.RunConfigSchema.parse({
+      transport: driverTestConfig.transport
+    });
+    client = _chunkUFWAK3X2cjs.createClientWithDriver.call(void 0, managerDriver, runConfig);
   } else {
-    _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
+    _chunkTCUI5JFEcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
   }
   if (!driverTestConfig.HACK_skipCleanupNet) {
     c.onTestFinished(async () => await client.dispose());
@@ -79,7 +560,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();
@@ -215,11 +696,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);
@@ -598,7 +1079,7 @@ function runActorScheduleTests(driverTestConfig) {
 
 // fixtures/driver-test-suite/sleep.ts
 var SLEEP_TIMEOUT = 500;
-var sleep = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+var sleep = _chunkTWGATZ3Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -624,7 +1105,7 @@ var sleep = _chunkVO7ZRVVDcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithLongRpc = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+var sleepWithLongRpc = _chunkTWGATZ3Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   createVars: () => ({}),
   onStart: (c) => {
@@ -653,7 +1134,7 @@ var sleepWithLongRpc = _chunkVO7ZRVVDcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawHttp = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+var sleepWithRawHttp = _chunkTWGATZ3Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, requestCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -667,7 +1148,7 @@ var sleepWithRawHttp = _chunkVO7ZRVVDcjs.actor.call(void 0, {
     if (url.pathname === "/long-request") {
       const duration = parseInt(url.searchParams.get("duration") || "1000");
       c.log.info({ msg: "starting long fetch request", duration });
-      await new Promise((resolve2) => setTimeout(resolve2, duration));
+      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" }
@@ -688,7 +1169,7 @@ var sleepWithRawHttp = _chunkVO7ZRVVDcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithRawWebSocket = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+var sleepWithRawWebSocket = _chunkTWGATZ3Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -751,7 +1232,7 @@ var sleepWithRawWebSocket = _chunkVO7ZRVVDcjs.actor.call(void 0, {
     sleepTimeout: SLEEP_TIMEOUT
   }
 });
-var sleepWithNoSleepOption = _chunkVO7ZRVVDcjs.actor.call(void 0, {
+var sleepWithNoSleepOption = _chunkTWGATZ3Xcjs.actor.call(void 0, {
   state: { startCount: 0, sleepCount: 0 },
   onStart: (c) => {
     c.state.startCount += 1;
@@ -908,7 +1389,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;
@@ -941,32 +1422,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();
@@ -1119,15 +1600,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(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
-            _vitest.expect.call(void 0, error.message).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_DESCRIPTION);
-          } else if (driverTestConfig.clientType === "inline") {
-            _vitest.expect.call(void 0, error.code).toBe(_chunkSBHHJ6QScjs.INTERNAL_ERROR_CODE);
-            _vitest.expect.call(void 0, error.message).toBe("This is an internal error");
-          } else {
-            _chunkGICQ3YCUcjs.assertUnreachable.call(void 0, driverTestConfig.clientType);
-          }
+          _vitest.expect.call(void 0, error.code).toBe(_chunk5QGQK44Lcjs.INTERNAL_ERROR_CODE);
+          _vitest.expect.call(void 0, error.message).toBe(_chunk5QGQK44Lcjs.INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -1465,11 +1939,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 = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1483,7 +1957,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 = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1506,7 +1980,7 @@ function runActorInspectorTests(driverTestConfig) {
         const actorKey2 = ["test-cursor-2"];
         await client.counter.create(actorKey1);
         await client.counter.create(actorKey2);
-        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1531,7 +2005,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should handle invalid limit parameter", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1543,7 +2017,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should create a new actor", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1567,7 +2041,7 @@ function runActorInspectorTests(driverTestConfig) {
       });
       _vitest.test.call(void 0, "should get builds", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
-        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1585,7 +2059,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 = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1599,7 +2073,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 = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1615,7 +2089,7 @@ function runActorInspectorTests(driverTestConfig) {
         const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
         const handle = await client.counter.create(["test-bootstrap"]);
         await handle.resolve();
-        const http = _chunkLWNKVZG5cjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createManagerInspectorClient.call(void 0, `${endpoint}/inspect`, {
           headers: {
             Authorization: `Bearer token`
           }
@@ -1637,10 +2111,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1652,10 +2126,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1670,10 +2144,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state"]);
         const actorId = await handle.resolve();
         await handle.increment(5);
-        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1692,10 +2166,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1717,10 +2191,10 @@ function runActorInspectorTests(driverTestConfig) {
         const handle = await client.counter.create(["test-state-patch"]);
         const actorId = await handle.resolve();
         await handle.increment(3);
-        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1751,10 +2225,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1776,10 +2250,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1802,10 +2276,10 @@ function runActorInspectorTests(driverTestConfig) {
         const actorId = await handle.resolve();
         handle.connect();
         await handle.increment(10);
-        const http = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1830,10 +2304,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1851,10 +2325,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -1875,10 +2349,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 = _chunkLWNKVZG5cjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
+        const http = _chunkKUPQZYUQcjs.createActorInspectorClient.call(void 0, `${endpoint}/actors/inspect`, {
           headers: {
             Authorization: `Bearer token`,
-            [_chunkGICQ3YCUcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
+            [_chunkTCUI5JFEcjs.HEADER_ACTOR_QUERY]: JSON.stringify({
               getForId: { name: "counter", actorId }
             })
           }
@@ -2887,24 +3361,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 }
         );
@@ -2919,22 +3393,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 }
         );
@@ -2948,21 +3422,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);
@@ -2975,23 +3449,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);
@@ -3000,11 +3474,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);
@@ -3024,18 +3498,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 }
             );
@@ -3064,18 +3538,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 }
         );
@@ -3090,15 +3564,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);
@@ -3111,15 +3585,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;
@@ -3129,7 +3603,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);
     });
@@ -3137,15 +3611,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 }
         );
@@ -3154,15 +3628,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 }
         );
@@ -3173,8 +3647,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++) {
@@ -3182,12 +3656,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++) {
@@ -3195,7 +3669,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);
     });
@@ -3203,15 +3677,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);
@@ -3362,7 +3836,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     };
   } else {
     let upgradeWebSocket;
-    const config = _chunkWHBPJNGWcjs.RunConfigSchema.parse({
+    const config = _chunkNTCUGYSDcjs.RunConfigSchema.parse({
       driver,
       getUpgradeWebSocket: () => upgradeWebSocket,
       inspector: {
@@ -3371,7 +3845,7 @@ async function createTestRuntime(registryPath, driverFactory) {
       }
     });
     const managerDriver = driver.manager(registry.config, config);
-    const { router } = _chunkVO7ZRVVDcjs.createManagerRouter.call(void 0, 
+    const { router } = _chunkTWGATZ3Xcjs.createManagerRouter.call(void 0, 
       registry.config,
       config,
       managerDriver,
@@ -3379,7 +3853,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     );
     const nodeWebSocket = _nodews.createNodeWebSocket.call(void 0, { app: router });
     upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
-    const port = await _chunkIH6CKNDWcjs.getPort.call(void 0, );
+    const port = await _chunk6P6RA47Ncjs.getPort.call(void 0, );
     const server = _nodeserver.serve.call(void 0, {
       fetch: router.fetch,
       hostname: "127.0.0.1",
@@ -3393,7 +3867,7 @@ async function createTestRuntime(registryPath, driverFactory) {
     const serverEndpoint = `http://127.0.0.1:${port}`;
     logger().info({ msg: "test serer listening", port });
     const cleanup = async () => {
-      await new Promise((resolve2) => server.close(() => resolve2(void 0)));
+      await new Promise((resolve) => server.close(() => resolve(void 0)));
       await (driverCleanup == null ? void 0 : driverCleanup());
     };
     return {