@rivetkit/engine-runner 25.8.0 → 25.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivetkit/engine-runner",
-  "version": "25.8.0",
+  "version": "25.8.3",
   "type": "module",
   "exports": {
     "import": {
@@ -16,7 +16,7 @@
     "uuid": "^12.0.0",
     "pino": "^9.9.5",
     "ws": "^8.18.3",
-    "@rivetkit/engine-runner-protocol": "25.8.0"
+    "@rivetkit/engine-runner-protocol": "25.8.3"
   },
   "devDependencies": {
     "@types/node": "^22.18.1",

package/src/log.ts

@@ -1,6 +1,6 @@
-import { Logger } from "pino";
+import type { Logger } from "pino";
 
-let LOGGER: Logger | undefined = undefined;
+let LOGGER: Logger | undefined;
 
 export function setLogger(logger: Logger) {
 	LOGGER = logger;

package/src/mod.ts

@@ -1,17 +1,18 @@
-import type WebSocket from "ws";
-import { importWebSocket } from "./websocket.js";
 import * as protocol from "@rivetkit/engine-runner-protocol";
-import { unreachable, calculateBackoff } from "./utils";
+import type { Logger } from "pino";
+import type WebSocket from "ws";
+import { logger, setLogger } from "./log.js";
 import { Tunnel } from "./tunnel";
+import { calculateBackoff, unreachable } from "./utils";
+import { importWebSocket } from "./websocket.js";
 import type { WebSocketTunnelAdapter } from "./websocket-tunnel-adapter";
-import type { Logger } from "pino";
-import { setLogger, logger } from "./log.js";
 
 const KV_EXPIRE: number = 30_000;
 const PROTOCOL_VERSION: number = 1;
 
 /** Warn once the backlog significantly exceeds the server's ack batch size. */
 const EVENT_BACKLOG_WARN_THRESHOLD = 10_000;
+const SIGNAL_HANDLERS: (() => void)[] = [];
 
 export interface ActorInstance {
 	actorId: string;
@@ -44,8 +45,17 @@ export interface RunnerConfig {
 	onConnected: () => void;
 	onDisconnected: () => void;
 	onShutdown: () => void;
-	fetch: (actorId: string, request: Request) => Promise<Response>;
-	websocket?: (actorId: string, ws: any, request: Request) => Promise<void>;
+	fetch: (
+		runner: Runner,
+		actorId: string,
+		request: Request,
+	) => Promise<Response>;
+	websocket?: (
+		runner: Runner,
+		actorId: string,
+		ws: any,
+		request: Request,
+	) => Promise<void>;
 	onActorStart: (
 		actorId: string,
 		generation: number,
@@ -107,14 +117,12 @@ export class Runner {
 	#kvCleanupInterval?: NodeJS.Timeout;
 
 	// Tunnel for HTTP/WebSocket forwarding
-	#tunnel: Tunnel;
+	#tunnel: Tunnel | undefined;
 
 	constructor(config: RunnerConfig) {
 		this.#config = config;
 		if (this.#config.logger) setLogger(this.#config.logger);
 
-		this.#tunnel = new Tunnel(this);
-
 		// Start cleaning up old unsent KV requests every 15 seconds
 		this.#kvCleanupInterval = setInterval(() => {
 			this.#cleanupOldKvRequests();
@@ -134,11 +142,21 @@ export class Runner {
 	}
 
 	async stopActor(actorId: string, generation?: number) {
+		const actor = this.getActor(actorId, generation);
+		if (!actor) return;
+
+		this.#sendActorIntent(actorId, actor.generation, "stop");
+
+		// NOTE: We do NOT remove the actor from this.#actors here
+		// The server will send a StopActor command if it wants to fully stop
+	}
+
+	async forceStopActor(actorId: string, generation?: number) {
 		const actor = this.#removeActor(actorId, generation);
 		if (!actor) return;
 
 		// Unregister actor from tunnel
-		this.#tunnel.unregisterActor(actor);
+		this.#tunnel?.unregisterActor(actor);
 
 		// If onActorStop times out, Pegboard will handle this timeout with ACTOR_STOP_THRESHOLD_DURATION_MS
 		try {
@@ -152,6 +170,7 @@ export class Runner {
 		this.#config.onActorStop(actorId, actor.generation).catch((err) => {
 			logger()?.error({
 				msg: "error in onactorstop for actor",
+				runnerId: this.runnerId,
 				actorId,
 				err,
 			});
@@ -159,25 +178,31 @@ export class Runner {
 	}
 
 	#stopAllActors() {
-		logger()?.info(
-			"stopping all actors due to runner lost threshold exceeded",
-		);
+		logger()?.info({
+			msg: "stopping all actors due to runner lost threshold exceeded",
+			runnerId: this.runnerId,
+		});
 
 		const actorIds = Array.from(this.#actors.keys());
 		for (const actorId of actorIds) {
-			this.stopActor(actorId);
+			this.forceStopActor(actorId);
 		}
 	}
 
 	getActor(actorId: string, generation?: number): ActorInstance | undefined {
 		const actor = this.#actors.get(actorId);
 		if (!actor) {
-			logger()?.error({ msg: "actor not found", actorId });
+			logger()?.error({
+				msg: "actor not found",
+				runnerId: this.runnerId,
+				actorId,
+			});
 			return undefined;
 		}
 		if (generation !== undefined && actor.generation !== generation) {
 			logger()?.error({
 				msg: "actor generation mismatch",
+				runnerId: this.runnerId,
 				actorId,
 				generation,
 			});
@@ -202,12 +227,17 @@ export class Runner {
 	): ActorInstance | undefined {
 		const actor = this.#actors.get(actorId);
 		if (!actor) {
-			logger()?.error({ msg: "actor not found for removal", actorId });
+			logger()?.error({
+				msg: "actor not found for removal",
+				runnerId: this.runnerId,
+				actorId,
+			});
 			return undefined;
 		}
 		if (generation !== undefined && actor.generation !== generation) {
 			logger()?.error({
 				msg: "actor generation mismatch",
+				runnerId: this.runnerId,
 				actorId,
 				generation,
 			});
@@ -225,6 +255,7 @@ export class Runner {
 				} catch (err) {
 					logger()?.error({
 						msg: "error closing websocket for actor",
+						runnerId: this.runnerId,
 						actorId,
 						err,
 					});
@@ -241,8 +272,9 @@ export class Runner {
 		if (this.#started) throw new Error("Cannot call runner.start twice");
 		this.#started = true;
 
-		logger()?.info("starting runner");
+		logger()?.info({ msg: "starting runner" });
 
+		this.#tunnel = new Tunnel(this);
 		this.#tunnel.start();
 
 		try {
@@ -253,14 +285,46 @@ export class Runner {
 		}
 
 		if (!this.#config.noAutoShutdown) {
-			process.on("SIGTERM", this.shutdown.bind(this, false, true));
-			process.on("SIGINT", this.shutdown.bind(this, false, true));
+			if (!SIGNAL_HANDLERS.length) {
+				process.on("SIGTERM", () => {
+					logger()?.debug("received SIGTERM");
+
+					for (const handler of SIGNAL_HANDLERS) {
+						handler();
+					}
+
+					process.exit(0);
+				});
+				process.on("SIGINT", () => {
+					logger()?.debug("received SIGINT");
+
+					for (const handler of SIGNAL_HANDLERS) {
+						handler();
+					}
+
+					process.exit(0);
+				});
+
+				logger()?.debug({
+					msg: "added SIGTERM listeners",
+				});
+			}
+
+			SIGNAL_HANDLERS.push(() => {
+				const weak = new WeakRef(this);
+				weak.deref()?.shutdown(false, false);
+			});
 		}
 	}
 
 	// MARK: Shutdown
 	async shutdown(immediate: boolean, exit: boolean = false) {
-		logger()?.info({ msg: "starting shutdown...", immediate });
+		logger()?.info({
+			msg: "starting shutdown",
+			runnerId: this.runnerId,
+			immediate,
+			exit,
+		});
 		this.#shutdown = true;
 
 		// Clear reconnect timeout
@@ -315,6 +379,7 @@ export class Runner {
 				try {
 					logger()?.info({
 						msg: "sending stopping message",
+						runnerId: this.runnerId,
 						readyState: pegboardWebSocket.readyState,
 					});
 
@@ -342,6 +407,7 @@ export class Runner {
 						pegboardWebSocket.addEventListener("close", (ev) => {
 							logger()?.info({
 								msg: "connection closed",
+								runnerId: this.runnerId,
 								code: ev.code,
 								reason: ev.reason.toString(),
 							});
@@ -351,28 +417,39 @@ export class Runner {
 
 					// TODO: Wait for all actors to stop before closing ws
 
-					logger()?.info("closing WebSocket");
+					logger()?.info({
+						msg: "closing WebSocket",
+						runnerId: this.runnerId,
+					});
 					pegboardWebSocket.close(1000, "Stopping");
 
 					await closePromise;
 
-					logger()?.info("websocket shutdown completed");
+					logger()?.info({
+						msg: "websocket shutdown completed",
+						runnerId: this.runnerId,
+					});
 				} catch (error) {
 					logger()?.error({
 						msg: "error during websocket shutdown:",
+						runnerId: this.runnerId,
 						error,
 					});
 					pegboardWebSocket.close();
 				}
 			}
 		} else {
-			logger()?.warn("no runner WebSocket to shutdown or already closed");
+			logger()?.warn({
+				msg: "no runner WebSocket to shutdown or already closed",
+				runnerId: this.runnerId,
+				readyState: this.#pegboardWebSocket?.readyState,
+			});
 		}
 
 		// Close tunnel
 		if (this.#tunnel) {
 			this.#tunnel.shutdown();
-			logger()?.info("tunnel shutdown completed");
+			this.#tunnel = undefined;
 		}
 
 		if (exit) process.exit(0);
@@ -400,7 +477,7 @@ export class Runner {
 		this.#pegboardWebSocket = ws;
 
 		ws.addEventListener("open", () => {
-			logger()?.info("Connected");
+			logger()?.info({ msg: "Connected" });
 
 			// Reset reconnect attempt counter on successful connection
 			this.#reconnectAttempt = 0;
@@ -457,7 +534,10 @@ export class Runner {
 					});
 				} else {
 					clearInterval(pingLoop);
-					logger()?.info("WebSocket not open, stopping ping loop");
+					logger()?.info({
+						msg: "WebSocket not open, stopping ping loop",
+						runnerId: this.runnerId,
+					});
 				}
 			}, pingInterval);
 			this.#pingLoop = pingLoop;
@@ -469,7 +549,10 @@ export class Runner {
 					this.#sendCommandAcknowledgment();
 				} else {
 					clearInterval(ackLoop);
-					logger()?.info("WebSocket not open, stopping ack loop");
+					logger()?.info({
+						msg: "WebSocket not open, stopping ack loop",
+						runnerId: this.runnerId,
+					});
 				}
 			}, ackInterval);
 			this.#ackInterval = ackLoop;
@@ -492,7 +575,7 @@ export class Runner {
 			if (message.tag === "ToClientInit") {
 				const init = message.val;
 
-				if (this.runnerId != init.runnerId) {
+				if (this.runnerId !== init.runnerId) {
 					this.runnerId = init.runnerId;
 
 					// Clear history if runner id changed
@@ -526,7 +609,7 @@ export class Runner {
 			} else if (message.tag === "ToClientTunnelMessage") {
 				this.#tunnel?.handleTunnelMessage(message.val);
 			} else if (message.tag === "ToClientClose") {
-				this.#tunnel.shutdown();
+				this.#tunnel?.shutdown();
 				ws.close(1000, "manual closure");
 			} else {
 				unreachable(message);
@@ -534,7 +617,10 @@ export class Runner {
 		});
 
 		ws.addEventListener("error", (ev) => {
-			logger()?.error(`WebSocket error: ${ev.error}`);
+			logger()?.error({
+				msg: `WebSocket error: ${ev.error}`,
+				runnerId: this.runnerId,
+			});
 
 			if (!this.#shutdown) {
 				// Start runner lost timeout if we have a threshold and are not shutting down
@@ -545,6 +631,7 @@ export class Runner {
 				) {
 					logger()?.info({
 						msg: "starting runner lost timeout",
+						runnerId: this.runnerId,
 						seconds: this.#runnerLostThreshold / 1000,
 					});
 					this.#runnerLostTimeout = setTimeout(() => {
@@ -560,14 +647,18 @@ export class Runner {
 		ws.addEventListener("close", async (ev) => {
 			logger()?.info({
 				msg: "connection closed",
+				runnerId: this.runnerId,
 				code: ev.code,
 				reason: ev.reason.toString(),
 			});
 
 			this.#config.onDisconnected();
 
-			if (ev.reason.toString() == "ws.eviction") {
-				logger()?.info("runner evicted");
+			if (ev.reason.toString().startsWith("ws.eviction")) {
+				logger()?.info({
+					msg: "runner evicted",
+					runnerId: this.runnerId,
+				});
 
 				await this.shutdown(true);
 			}
@@ -593,6 +684,7 @@ export class Runner {
 				) {
 					logger()?.info({
 						msg: "starting runner lost timeout",
+						runnerId: this.runnerId,
 						seconds: this.#runnerLostThreshold / 1000,
 					});
 					this.#runnerLostTimeout = setTimeout(() => {
@@ -609,11 +701,16 @@ export class Runner {
 	#handleCommands(commands: protocol.ToClientCommands) {
 		logger()?.info({
 			msg: "received commands",
+			runnerId: this.runnerId,
 			commandCount: commands.length,
 		});
 
 		for (const commandWrapper of commands) {
-			logger()?.info({ msg: "received command", commandWrapper });
+			logger()?.info({
+				msg: "received command",
+				runnerId: this.runnerId,
+				commandWrapper,
+			});
 			if (commandWrapper.inner.tag === "CommandStartActor") {
 				this.#handleCommandStartActor(commandWrapper);
 			} else if (commandWrapper.inner.tag === "CommandStopActor") {
@@ -638,6 +735,7 @@ export class Runner {
 		if (prunedCount > 0) {
 			logger()?.info({
 				msg: "pruned acknowledged events",
+				runnerId: this.runnerId,
 				lastAckedIdx: lastAckedIdx.toString(),
 				prunedCount,
 			});
@@ -659,6 +757,7 @@ export class Runner {
 			this.#eventBacklogWarned = true;
 			logger()?.warn({
 				msg: "unacknowledged event backlog exceeds threshold",
+				runnerId: this.runnerId,
 				backlogSize: this.#eventHistory.length,
 				threshold: EVENT_BACKLOG_WARN_THRESHOLD,
 			});
@@ -699,13 +798,14 @@ export class Runner {
 			.catch((err) => {
 				logger()?.error({
 					msg: "error in onactorstart for actor",
+					runnerId: this.runnerId,
 					actorId,
 					err,
 				});
 
 				// TODO: Mark as crashed
 				// Send stopped state update if start failed
-				this.stopActor(actorId, generation);
+				this.forceStopActor(actorId, generation);
 			});
 	}
 
@@ -716,7 +816,7 @@ export class Runner {
 		const actorId = stopCommand.actorId;
 		const generation = stopCommand.generation;
 
-		this.stopActor(actorId, generation);
+		this.forceStopActor(actorId, generation);
 	}
 
 	#sendActorIntent(
@@ -725,7 +825,10 @@ export class Runner {
 		intentType: "sleep" | "stop",
 	) {
 		if (this.#shutdown) {
-			logger()?.warn("Runner is shut down, cannot send actor intent");
+			logger()?.warn({
+				msg: "Runner is shut down, cannot send actor intent",
+				runnerId: this.runnerId,
+			});
 			return;
 		}
 		let actorIntent: protocol.ActorIntent;
@@ -760,6 +863,7 @@ export class Runner {
 
 		logger()?.info({
 			msg: "sending event to server",
+			runnerId: this.runnerId,
 			index: eventWrapper.index,
 			tag: eventWrapper.inner.tag,
 			val: eventWrapper.inner.val,
@@ -777,9 +881,10 @@ export class Runner {
 		stateType: "running" | "stopped",
 	) {
 		if (this.#shutdown) {
-			logger()?.warn(
-				"Runner is shut down, cannot send actor state update",
-			);
+			logger()?.warn({
+				msg: "Runner is shut down, cannot send actor state update",
+				runnerId: this.runnerId,
+			});
 			return;
 		}
 		let actorState: protocol.ActorState;
@@ -817,6 +922,7 @@ export class Runner {
 
 		logger()?.info({
 			msg: "sending event to server",
+			runnerId: this.runnerId,
 			index: eventWrapper.index,
 			tag: eventWrapper.inner.tag,
 			val: eventWrapper.inner.val,
@@ -830,9 +936,10 @@ export class Runner {
 
 	#sendCommandAcknowledgment() {
 		if (this.#shutdown) {
-			logger()?.warn(
-				"Runner is shut down, cannot send command acknowledgment",
-			);
+			logger()?.warn({
+				msg: "Runner is shut down, cannot send command acknowledgment",
+				runnerId: this.runnerId,
+			});
 			return;
 		}
 
@@ -857,11 +964,7 @@ export class Runner {
 
 		if (!request) {
 			const msg = "received kv response for unknown request id";
-			if (logger()) {
-				logger()?.error({ msg, requestId });
-			} else {
-				logger()?.error({ msg, requestId });
-			}
+			logger()?.error({ msg, runnerId: this.runnerId, requestId });
 			return;
 		}
 
@@ -1266,9 +1369,10 @@ export class Runner {
 
 	__sendToServer(message: protocol.ToServer) {
 		if (this.#shutdown) {
-			logger()?.warn(
-				"Runner is shut down, cannot send message to server",
-			);
+			logger()?.warn({
+				msg: "Runner is shut down, cannot send message to server",
+				runnerId: this.runnerId,
+			});
 			return;
 		}
 
@@ -1279,16 +1383,17 @@ export class Runner {
 		) {
 			this.#pegboardWebSocket.send(encoded);
 		} else {
-			logger()?.error(
-				"WebSocket not available or not open for sending data",
-			);
+			logger()?.error({
+				msg: "WebSocket not available or not open for sending data",
+				runnerId: this.runnerId,
+			});
 		}
 	}
 
 	getServerlessInitPacket(): string | undefined {
 		if (!this.runnerId) return undefined;
 
-		let data = protocol.encodeToServerlessServer({
+		const data = protocol.encodeToServerlessServer({
 			tag: "ToServerlessServerInit",
 			val: {
 				runnerId: this.runnerId,
@@ -1305,7 +1410,10 @@ export class Runner {
 
 	#scheduleReconnect() {
 		if (this.#shutdown) {
-			logger()?.debug("Runner is shut down, not attempting reconnect");
+			logger()?.debug({
+				msg: "Runner is shut down, not attempting reconnect",
+				runnerId: this.runnerId,
+			});
 			return;
 		}
 
@@ -1316,16 +1424,18 @@ export class Runner {
 			jitter: true,
 		});
 
-		logger()?.debug(
-			`Scheduling reconnect attempt ${this.#reconnectAttempt + 1} in ${delay}ms`,
-		);
+		logger()?.debug({
+			msg: `Scheduling reconnect attempt ${this.#reconnectAttempt + 1} in ${delay}ms`,
+			runnerId: this.runnerId,
+		});
 
 		this.#reconnectTimeout = setTimeout(async () => {
 			if (!this.#shutdown) {
 				this.#reconnectAttempt++;
-				logger()?.debug(
-					`Attempting to reconnect (attempt ${this.#reconnectAttempt})...`,
-				);
+				logger()?.debug({
+					msg: `Attempting to reconnect (attempt ${this.#reconnectAttempt})...`,
+					runnerId: this.runnerId,
+				});
 				await this.#openPegboardWebSocket();
 			}
 		}, delay);

package/src/tunnel.ts

@@ -1,10 +1,10 @@
-import * as protocol from "@rivetkit/engine-runner-protocol";
-import type { RequestId, MessageId } from "@rivetkit/engine-runner-protocol";
-import { WebSocketTunnelAdapter } from "./websocket-tunnel-adapter";
-import type { Runner, ActorInstance } from "./mod";
+import type * as protocol from "@rivetkit/engine-runner-protocol";
+import type { MessageId, RequestId } from "@rivetkit/engine-runner-protocol";
 import { v4 as uuidv4 } from "uuid";
 import { logger } from "./log";
+import type { ActorInstance, Runner } from "./mod";
 import { unreachable } from "./utils";
+import { WebSocketTunnelAdapter } from "./websocket-tunnel-adapter";
 
 const GC_INTERVAL = 60000; // 60 seconds
 const MESSAGE_ACK_TIMEOUT = 5000; // 5 seconds
@@ -48,8 +48,6 @@ export class Tunnel {
 			this.#gcInterval = undefined;
 		}
 
-		// TODO: Should we use unregisterActor instead
-
 		// Reject all pending requests
 		for (const [_, request] of this.#actorPendingRequests) {
 			request.reject(new Error("Tunnel shutting down"));
@@ -212,7 +210,11 @@ export class Tunnel {
 			return new Response("Actor not found", { status: 404 });
 		}
 
-		const fetchHandler = this.#runner.config.fetch(actorId, request);
+		const fetchHandler = this.#runner.config.fetch(
+			this.#runner,
+			actorId,
+			request,
+		);
 
 		if (!fetchHandler) {
 			return new Response("Not Implemented", { status: 501 });
@@ -541,7 +543,12 @@ export class Tunnel {
 			});
 
 			// Call websocket handler
-			await websocketHandler(open.actorId, adapter, request);
+			await websocketHandler(
+				this.#runner,
+				open.actorId,
+				adapter,
+				request,
+			);
 		} catch (error) {
 			logger()?.error({ msg: "error handling websocket open", error });
 			// Send close on error

package/src/utils.ts

@@ -20,7 +20,7 @@ export function calculateBackoff(
 		jitter = true,
 	} = options;
 
-	let delay = Math.min(initialDelay * Math.pow(multiplier, attempt), maxDelay);
+	let delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
 
 	if (jitter) {
 		// Add random jitter between 0% and 25% of the delay

package/src/websocket-tunnel-adapter.ts

@@ -18,7 +18,7 @@ export class WebSocketTunnelAdapter {
 	#url = "";
 	#sendCallback: (data: ArrayBuffer | string, isBinary: boolean) => void;
 	#closeCallback: (code?: number, reason?: string) => void;
-	
+
 	// Event buffering for events fired before listeners are attached
 	#bufferedEvents: Array<{
 		type: string;
@@ -28,7 +28,7 @@ export class WebSocketTunnelAdapter {
 	constructor(
 		webSocketId: string,
 		sendCallback: (data: ArrayBuffer | string, isBinary: boolean) => void,
-		closeCallback: (code?: number, reason?: string) => void
+		closeCallback: (code?: number, reason?: string) => void,
 	) {
 		this.#webSocketId = webSocketId;
 		this.#sendCallback = sendCallback;
@@ -48,7 +48,11 @@ export class WebSocketTunnelAdapter {
 	}
 
 	set binaryType(value: string) {
-		if (value === "nodebuffer" || value === "arraybuffer" || value === "blob") {
+		if (
+			value === "nodebuffer" ||
+			value === "arraybuffer" ||
+			value === "blob"
+		) {
 			this.#binaryType = value;
 		}
 	}
@@ -114,7 +118,8 @@ export class WebSocketTunnelAdapter {
 	}
 
 	send(data: string | ArrayBuffer | ArrayBufferView | Blob | Buffer): void {
-		if (this.#readyState !== 1) { // OPEN
+		if (this.#readyState !== 1) {
+			// OPEN
 			throw new Error("WebSocket is not open");
 		}
 
@@ -133,29 +138,43 @@ export class WebSocketTunnelAdapter {
 			// Check if it's a SharedArrayBuffer
 			if (view.buffer instanceof SharedArrayBuffer) {
 				// Copy SharedArrayBuffer to regular ArrayBuffer
-				const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-				messageData = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as unknown as ArrayBuffer;
+				const bytes = new Uint8Array(
+					view.buffer,
+					view.byteOffset,
+					view.byteLength,
+				);
+				messageData = bytes.buffer.slice(
+					bytes.byteOffset,
+					bytes.byteOffset + bytes.byteLength,
+				) as unknown as ArrayBuffer;
 			} else {
 				messageData = view.buffer.slice(
 					view.byteOffset,
-					view.byteOffset + view.byteLength
+					view.byteOffset + view.byteLength,
 				) as ArrayBuffer;
 			}
 		} else if (data instanceof Blob) {
 			throw new Error("Blob sending not implemented in tunnel adapter");
-		} else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
+		} else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
 			isBinary = true;
 			// Convert Buffer to ArrayBuffer
 			const buf = data as Buffer;
 			// Check if it's a SharedArrayBuffer
 			if (buf.buffer instanceof SharedArrayBuffer) {
 				// Copy SharedArrayBuffer to regular ArrayBuffer
-				const bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-				messageData = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as unknown as ArrayBuffer;
+				const bytes = new Uint8Array(
+					buf.buffer,
+					buf.byteOffset,
+					buf.byteLength,
+				);
+				messageData = bytes.buffer.slice(
+					bytes.byteOffset,
+					bytes.byteOffset + bytes.byteLength,
+				) as unknown as ArrayBuffer;
 			} else {
 				messageData = buf.buffer.slice(
 					buf.byteOffset,
-					buf.byteOffset + buf.byteLength
+					buf.byteOffset + buf.byteLength,
 				) as ArrayBuffer;
 			}
 		} else {
@@ -169,7 +188,7 @@ export class WebSocketTunnelAdapter {
 	close(code?: number, reason?: string): void {
 		if (
 			this.#readyState === 2 || // CLOSING
-			this.#readyState === 3    // CLOSED
+			this.#readyState === 3 // CLOSED
 		) {
 			return;
 		}
@@ -181,7 +200,7 @@ export class WebSocketTunnelAdapter {
 
 		// Update state and fire event
 		this.#readyState = 3; // CLOSED
-		
+
 		const closeEvent = {
 			wasClean: true,
 			code: code || 1000,
@@ -189,14 +208,14 @@ export class WebSocketTunnelAdapter {
 			type: "close",
 			target: this,
 		};
-		
+
 		this.#fireEvent("close", closeEvent);
 	}
 
 	addEventListener(
 		type: string,
 		listener: (event: any) => void,
-		options?: boolean | any
+		options?: boolean | any,
 	): void {
 		if (typeof listener === "function") {
 			let listeners = this.#eventListeners.get(type);
@@ -214,7 +233,7 @@ export class WebSocketTunnelAdapter {
 	removeEventListener(
 		type: string,
 		listener: (event: any) => void,
-		options?: boolean | any
+		options?: boolean | any,
 	): void {
 		if (typeof listener === "function") {
 			const listeners = this.#eventListeners.get(type);
@@ -237,12 +256,16 @@ export class WebSocketTunnelAdapter {
 		if (listeners && listeners.size > 0) {
 			hasListeners = true;
 			for (const listener of listeners) {
-					try {
-						listener.call(this, event);
-					} catch (error) {
-						logger()?.error({ msg: "error in websocket event listener", error, type });
-					}
+				try {
+					listener.call(this, event);
+				} catch (error) {
+					logger()?.error({
+						msg: "error in websocket event listener",
+						error,
+						type,
+					});
 				}
+			}
 		}
 
 		// Call the onX property if set
@@ -253,7 +276,10 @@ export class WebSocketTunnelAdapter {
 					try {
 						this.#onopen.call(this, event);
 					} catch (error) {
-						logger()?.error({ msg: "error in onopen handler", error });
+						logger()?.error({
+							msg: "error in onopen handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -263,7 +289,10 @@ export class WebSocketTunnelAdapter {
 					try {
 						this.#onclose.call(this, event);
 					} catch (error) {
-						logger()?.error({ msg: "error in onclose handler", error });
+						logger()?.error({
+							msg: "error in onclose handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -273,7 +302,10 @@ export class WebSocketTunnelAdapter {
 					try {
 						this.#onerror.call(this, event);
 					} catch (error) {
-						logger()?.error({ msg: "error in onerror handler", error });
+						logger()?.error({
+							msg: "error in onerror handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -283,7 +315,10 @@ export class WebSocketTunnelAdapter {
 					try {
 						this.#onmessage.call(this, event);
 					} catch (error) {
-						logger()?.error({ msg: "error in onmessage handler", error });
+						logger()?.error({
+							msg: "error in onmessage handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -297,10 +332,10 @@ export class WebSocketTunnelAdapter {
 
 	#flushBufferedEvents(type: string): void {
 		const eventsToFlush = this.#bufferedEvents.filter(
-			(buffered) => buffered.type === type
+			(buffered) => buffered.type === type,
 		);
 		this.#bufferedEvents = this.#bufferedEvents.filter(
-			(buffered) => buffered.type !== type
+			(buffered) => buffered.type !== type,
 		);
 
 		for (const { event } of eventsToFlush) {
@@ -327,7 +362,10 @@ export class WebSocketTunnelAdapter {
 						try {
 							this.#onopen.call(this, event);
 						} catch (error) {
-							logger()?.error({ msg: "error in onopen handler", error });
+							logger()?.error({
+								msg: "error in onopen handler",
+								error,
+							});
 						}
 					}
 					break;
@@ -336,7 +374,10 @@ export class WebSocketTunnelAdapter {
 						try {
 							this.#onclose.call(this, event);
 						} catch (error) {
-							logger()?.error({ msg: "error in onclose handler", error });
+							logger()?.error({
+								msg: "error in onclose handler",
+								error,
+							});
 						}
 					}
 					break;
@@ -345,7 +386,10 @@ export class WebSocketTunnelAdapter {
 						try {
 							this.#onerror.call(this, event);
 						} catch (error) {
-							logger()?.error({ msg: "error in onerror handler", error });
+							logger()?.error({
+								msg: "error in onerror handler",
+								error,
+							});
 						}
 					}
 					break;
@@ -354,7 +398,10 @@ export class WebSocketTunnelAdapter {
 						try {
 							this.#onmessage.call(this, event);
 						} catch (error) {
-							logger()?.error({ msg: "error in onmessage handler", error });
+							logger()?.error({
+								msg: "error in onmessage handler",
+								error,
+							});
 						}
 					}
 					break;
@@ -364,27 +411,29 @@ export class WebSocketTunnelAdapter {
 
 	// Internal methods called by the Tunnel class
 	_handleOpen(): void {
-		if (this.#readyState !== 0) { // CONNECTING
+		if (this.#readyState !== 0) {
+			// CONNECTING
 			return;
 		}
 
 		this.#readyState = 1; // OPEN
-		
+
 		const event = {
 			type: "open",
 			target: this,
 		};
-		
+
 		this.#fireEvent("open", event);
 	}
 
 	_handleMessage(data: string | Uint8Array, isBinary: boolean): void {
-		if (this.#readyState !== 1) { // OPEN
+		if (this.#readyState !== 1) {
+			// OPEN
 			return;
 		}
 
 		let messageData: any;
-		
+
 		if (isBinary) {
 			// Handle binary data based on binaryType
 			if (this.#binaryType === "nodebuffer") {
@@ -395,14 +444,16 @@ export class WebSocketTunnelAdapter {
 				if (data instanceof Uint8Array) {
 					messageData = data.buffer.slice(
 						data.byteOffset,
-						data.byteOffset + data.byteLength
+						data.byteOffset + data.byteLength,
 					);
 				} else {
 					messageData = data;
 				}
 			} else {
 				// Blob type - not commonly used in Node.js
-				throw new Error("Blob binaryType not supported in tunnel adapter");
+				throw new Error(
+					"Blob binaryType not supported in tunnel adapter",
+				);
 			}
 		} else {
 			messageData = data;
@@ -418,7 +469,8 @@ export class WebSocketTunnelAdapter {
 	}
 
 	_handleClose(code?: number, reason?: string): void {
-		if (this.#readyState === 3) { // CLOSED
+		if (this.#readyState === 3) {
+			// CLOSED
 			return;
 		}
 
@@ -472,7 +524,7 @@ export class WebSocketTunnelAdapter {
 		// Immediate close without close frame
 		this.#readyState = 3; // CLOSED
 		this.#closeCallback(1006, "Abnormal Closure");
-		
+
 		const event = {
 			wasClean: false,
 			code: 1006,
@@ -480,7 +532,7 @@ export class WebSocketTunnelAdapter {
 			type: "close",
 			target: this,
 		};
-		
+
 		this.#fireEvent("close", event);
 	}
 }

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../../../tsconfig.base.json",
+	"extends": "../../../../tsconfig.base.json",
 	"compilerOptions": {
 		"types": ["node"],
 		"paths": {
@@ -7,7 +7,5 @@
 		}
 	},
 	"include": ["src/**/*", "tests/**/*", "benches/**/*"],
-	"exclude": [
-		"node_modules"
-	]
+	"exclude": ["node_modules"]
 }

package/tsup.config.ts

@@ -1,4 +1,4 @@
 import { defineConfig } from "tsup";
-import defaultConfig from "../../../tsup.base.ts";
+import defaultConfig from "../../../../tsup.base.ts";
 
 export default defineConfig(defaultConfig);

package/turbo.json

@@ -1,4 +1,4 @@
 {
-  "$schema": "https://turbo.build/schema.json",
-  "extends": ["//"]
+	"$schema": "https://turbo.build/schema.json",
+	"extends": ["//"]
 }

package/vitest.config.ts

@@ -1,6 +1,6 @@
-import { resolve } from "path";
+import { resolve } from "node:path";
 import { defineConfig } from "vitest/config";
-import defaultConfig from "../../../vitest.base.ts";
+import defaultConfig from "../../../../vitest.base.ts";
 
 export default defineConfig({
 	...defaultConfig,
@@ -14,4 +14,3 @@ export default defineConfig({
 		include: ["tests/**/*.test.ts"],
 	},
 });
-