rivetkit 2.0.4 → 2.0.6

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

@@ -1,39 +1,47 @@
 import {
   getPort
-} from "../chunk-3F2YSRJL.js";
-import {
-  createClient
-} from "../chunk-HI3HWJRC.js";
+} from "../chunk-G75SVQON.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-XJQHKJ4P.js";
+} from "../chunk-W6LN7AF5.js";
 import {
   createActorInspectorClient,
   createManagerInspectorClient
-} from "../chunk-H26RP6GD.js";
-import "../chunk-QK72M5JB.js";
+} from "../chunk-42I3OZ3Q.js";
+import {
+  createClient
+} from "../chunk-VPV4MWXR.js";
+import {
+  ActorError,
+  createClientWithDriver
+} from "../chunk-4CKHQRXG.js";
+import "../chunk-ZYLTS2EM.js";
+import {
+  importWebSocket
+} from "../chunk-VCEHU56K.js";
 import {
   RunConfigSchema
-} from "../chunk-TQ62L3X7.js";
+} from "../chunk-7OUKNSTU.js";
 import {
+  HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
   assertUnreachable
-} from "../chunk-HLLF4B4Q.js";
+} from "../chunk-2K3JMDAN.js";
 import {
   getLogger
-} from "../chunk-LV2S3OU3.js";
-import "../chunk-PQY7KKTL.js";
+} from "../chunk-WC2PSJWN.js";
+import "../chunk-RGQR2J7S.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-NFU2BBT5.js";
+} from "../chunk-YPZFLUO6.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
 import { createNodeWebSocket } from "@hono/node-ws";
 import { bundleRequire } from "bundle-require";
-import invariant from "invariant";
+import invariant2 from "invariant";
 import { describe as describe20 } from "vitest";
 
 // src/driver-test-suite/log.ts
@@ -45,16 +53,480 @@ function logger() {
 import { describe, expect, test } from "vitest";
 
 // src/driver-test-suite/utils.ts
-import { resolve } from "path";
+import invariant from "invariant";
 import { vi } from "vitest";
+
+// src/driver-test-suite/test-inline-client-driver.ts
+import * as cbor from "cbor-x";
+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(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 ActorError(
+                errorData.error.code,
+                errorData.error.message,
+                errorData.error.metadata
+              );
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof ActorError)) {
+            return response;
+          }
+          throw e;
+        }
+      }
+      return response;
+    },
+    async openWebSocket(path, actorId, encoding2, params) {
+      const WebSocket2 = await importWebSocket();
+      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 ActorError(
+      callResponse.err.group,
+      callResponse.err.code,
+      callResponse.err.message,
+      callResponse.err.metadata
+    );
+  } else {
+    assertUnreachable(callResponse);
+  }
+}
+
+// src/driver-test-suite/utils.ts
 var FAKE_TIME = /* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z");
 async function setupDriverTest(c, driverTestConfig) {
   if (!driverTestConfig.useRealTimers) {
     vi.useFakeTimers();
     vi.setSystemTime(FAKE_TIME);
   }
-  const projectPath = resolve(__dirname, "../../fixtures/driver-test-suite");
-  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start(projectPath);
+  const { endpoint, namespace, runnerName, cleanup } = await driverTestConfig.start();
   c.onTestFinished(cleanup);
   let client;
   if (driverTestConfig.clientType === "http") {
@@ -65,7 +537,16 @@ async function setupDriverTest(c, driverTestConfig) {
       transport: driverTestConfig.transport
     });
   } else if (driverTestConfig.clientType === "inline") {
-    throw "TODO";
+    const managerDriver = createTestInlineClientDriver(
+      endpoint,
+      "bare",
+      driverTestConfig.transport ?? "websocket"
+    );
+    invariant(driverTestConfig.transport, "missing transport");
+    const runConfig = RunConfigSchema.parse({
+      transport: driverTestConfig.transport
+    });
+    client = createClientWithDriver(managerDriver, runConfig);
   } else {
     assertUnreachable(driverTestConfig.clientType);
   }
@@ -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 {
     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);
@@ -667,7 +1148,7 @@ var sleepWithRawHttp = actor({
     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" }
@@ -908,7 +1389,7 @@ function runActorSleepTests(driverTestConfig) {
         expect5(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) {
         expect5(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);
           }
         };
       });
       expect5(counts.sleepCount).toBe(0);
       expect5(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();
           expect7(true).toBe(false);
         } catch (error) {
-          if (driverTestConfig.clientType === "http") {
-            expect7(error.code).toBe(INTERNAL_ERROR_CODE);
-            expect7(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
-          } else if (driverTestConfig.clientType === "inline") {
-            expect7(error.code).toBe(INTERNAL_ERROR_CODE);
-            expect7(error.message).toBe("This is an internal error");
-          } else {
-            assertUnreachable(driverTestConfig.clientType);
-          }
+          expect7(error.code).toBe(INTERNAL_ERROR_CODE);
+          expect7(error.message).toBe(INTERNAL_ERROR_DESCRIPTION);
         }
       });
     });
@@ -1465,7 +1939,7 @@ function runActorInlineClientTests(driverTestConfig) {
 // src/driver-test-suite/tests/actor-inspector.ts
 import { describe as describe11, expect as expect10, test as test10 } from "vitest";
 function runActorInspectorTests(driverTestConfig) {
-  describe11("Actor Inspector Tests", () => {
+  describe11.skip("Actor Inspector Tests", () => {
     describe11("Manager Inspector", () => {
       test10("should respond to ping", async (c) => {
         const { endpoint } = await setupDriverTest(c, driverTestConfig);
@@ -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();
       expect17(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));
       }
       expect17(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) {
       expect17(welcome1.type).toBe("welcome");
       expect17(welcome1.connectionCount).toBe(1);
       const ws2 = await actor2.websocket();
-      await new Promise((resolve2, reject) => {
-        ws2.addEventListener("open", () => resolve2(), { once: true });
+      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();
       expect17(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));
       }
       expect17(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));
       }
       expect17(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);
@@ -3385,7 +3859,7 @@ async function createTestRuntime(registryPath, driverFactory) {
       hostname: "127.0.0.1",
       port
     });
-    invariant(
+    invariant2(
       nodeWebSocket.injectWebSocket !== void 0,
       "should have injectWebSocket"
     );
@@ -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 {