@ricsam/isolate-client 0.1.15 → 0.1.17

package/dist/cjs/connection.cjs

@@ -42,6 +42,7 @@ var __export = (target, all) => {
 // packages/isolate-client/src/connection.ts
 var exports_connection = {};
 __export(exports_connection, {
+  isBenignDisposeError: () => isBenignDisposeError,
   connect: () => connect
 });
 module.exports = __toCommonJS(exports_connection);
@@ -49,11 +50,10 @@ var import_node_net = require("node:net");
 var import_node_path = __toESM(require("node:path"));
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_client = require("@ricsam/isolate-playwright/client");
-var DEFAULT_TIMEOUT = 30000;
-var TEST_REQUEST_TIMEOUT_BUFFER_MS = 1000;
 var isolateWsCallbacks = new Map;
 var isolateClientWebSockets = new Map;
 var isolateWebSocketCallbacks = new Map;
+var isolateEventListeners = new Map;
 async function connect(options = {}) {
   const socket = await createSocket(options);
   const state = {
@@ -68,47 +68,142 @@ async function connect(options = {}) {
     streamResponses: new Map,
     uploadStreams: new Map,
     moduleSourceCache: new Map,
-    callbackStreamReaders: new Map
+    callbackStreamReaders: new Map,
+    closing: false,
+    namespacedRuntimes: new Map
   };
-  const parser = import_isolate_protocol.createFrameParser();
-  socket.on("data", (data) => {
-    try {
-      for (const frame of parser.feed(new Uint8Array(data))) {
-        handleMessage(frame.message, state);
+  function setupSocket(sock) {
+    const parser = import_isolate_protocol.createFrameParser();
+    sock.on("data", (data) => {
+      try {
+        for (const frame of parser.feed(new Uint8Array(data))) {
+          handleMessage(frame.message, state);
+        }
+      } catch (err) {
+        console.error("Error parsing frame:", err);
       }
-    } catch (err) {
-      console.error("Error parsing frame:", err);
-    }
-  });
-  socket.on("close", () => {
-    state.connected = false;
-    for (const [, pending] of state.pendingRequests) {
-      if (pending.timeoutId) {
-        clearTimeout(pending.timeoutId);
+    });
+    sock.on("close", () => {
+      state.connected = false;
+      for (const [, pending] of state.pendingRequests) {
+        pending.reject(new Error("Connection closed"));
       }
-      pending.reject(new Error("Connection closed"));
-    }
-    state.pendingRequests.clear();
-    for (const [, receiver] of state.streamResponses) {
-      receiver.state = "errored";
-      receiver.error = new Error("Connection closed");
-      const resolvers = receiver.pullResolvers.splice(0);
-      for (const resolver of resolvers) {
-        resolver();
+      state.pendingRequests.clear();
+      for (const [, receiver] of state.streamResponses) {
+        receiver.state = "errored";
+        receiver.error = new Error("Connection closed");
+        const resolvers = receiver.pullResolvers.splice(0);
+        for (const resolver of resolvers) {
+          resolver();
+        }
       }
-    }
-    state.streamResponses.clear();
-    for (const [, session] of state.uploadStreams) {
-      session.state = "closed";
-      if (session.creditResolver) {
-        session.creditResolver();
+      state.streamResponses.clear();
+      for (const [, session] of state.uploadStreams) {
+        session.state = "closed";
+        if (session.creditResolver) {
+          session.creditResolver();
+        }
+      }
+      state.uploadStreams.clear();
+      if (!state.closing && state.namespacedRuntimes.size > 0) {
+        state.reconnecting = reconnect(state, options).catch(() => {
+          state.namespacedRuntimes.clear();
+          state.reconnecting = undefined;
+        });
       }
+    });
+    sock.on("error", (err) => {
+      if (!state.closing && state.namespacedRuntimes.size > 0)
+        return;
+      console.error("Socket error:", err);
+    });
+  }
+  setupSocket(socket);
+  async function reconnect(st, opts) {
+    try {
+      const newSocket = await createSocket(opts);
+      st.socket = newSocket;
+      st.connected = true;
+      setupSocket(newSocket);
+      for (const [namespaceId, descriptor] of st.namespacedRuntimes) {
+        const runtimeOptions = descriptor.runtimeOptions;
+        const callbacks = {};
+        if (runtimeOptions.console) {
+          callbacks.console = registerConsoleCallbacks(st, runtimeOptions.console);
+        }
+        if (runtimeOptions.fetch) {
+          callbacks.fetch = registerFetchCallback(st, runtimeOptions.fetch);
+        }
+        if (runtimeOptions.fs) {
+          callbacks.fs = registerFsCallbacks(st, runtimeOptions.fs);
+        }
+        if (runtimeOptions.moduleLoader) {
+          callbacks.moduleLoader = registerModuleLoaderCallback(st, runtimeOptions.moduleLoader);
+        }
+        if (runtimeOptions.customFunctions) {
+          callbacks.custom = registerCustomFunctions(st, runtimeOptions.customFunctions);
+        }
+        if (runtimeOptions.playwright) {
+          const playwrightHandler = runtimeOptions.playwright.handler;
+          if (playwrightHandler) {
+            const handlerCallbackId = st.nextCallbackId++;
+            st.callbacks.set(handlerCallbackId, async (opJson) => {
+              const op = JSON.parse(opJson);
+              const result2 = await playwrightHandler(op);
+              return JSON.stringify(result2);
+            });
+            callbacks.playwright = {
+              handlerCallbackId,
+              console: runtimeOptions.playwright.console && !runtimeOptions.console?.onEntry
+            };
+          }
+        }
+        let testEnvironmentOption;
+        if (runtimeOptions.testEnvironment) {
+          if (typeof runtimeOptions.testEnvironment === "object") {
+            const testEnvOptions = runtimeOptions.testEnvironment;
+            const testEnvCallbacks = {};
+            if (testEnvOptions.onEvent) {
+              const userOnEvent = testEnvOptions.onEvent;
+              const onEventCallbackId = registerEventCallback(st, (eventJson) => {
+                const event = JSON.parse(eventJson);
+                userOnEvent(event);
+              });
+              testEnvCallbacks.onEvent = {
+                callbackId: onEventCallbackId,
+                name: "testEnvironment.onEvent",
+                type: "sync"
+              };
+            }
+            testEnvironmentOption = {
+              callbacks: testEnvCallbacks,
+              testTimeout: testEnvOptions.testTimeout
+            };
+          } else {
+            testEnvironmentOption = true;
+          }
+        }
+        const requestId = st.nextRequestId++;
+        const request = {
+          type: import_isolate_protocol.MessageType.CREATE_RUNTIME,
+          requestId,
+          options: {
+            memoryLimitMB: runtimeOptions.memoryLimitMB,
+            cwd: runtimeOptions.cwd,
+            callbacks,
+            testEnvironment: testEnvironmentOption,
+            namespaceId
+          }
+        };
+        const result = await sendRequest(st, request);
+        descriptor.isolateId = result.isolateId;
+      }
+      st.reconnecting = undefined;
+    } catch {
+      st.reconnecting = undefined;
+      throw new Error("Failed to reconnect to daemon");
     }
-    state.uploadStreams.clear();
-  });
-  socket.on("error", (err) => {
-    console.error("Socket error:", err);
-  });
+  }
   return {
     createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions),
     createNamespace: (id) => ({
@@ -116,15 +211,16 @@ async function connect(options = {}) {
       createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions, id)
     }),
     close: async () => {
+      state.closing = true;
       state.connected = false;
-      socket.destroy();
+      state.socket.destroy();
     },
     isConnected: () => state.connected
   };
 }
 function createSocket(options) {
   return new Promise((resolve, reject) => {
-    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const timeout = options.timeout;
     let socket;
     const onError = (err) => {
       reject(err);
@@ -139,13 +235,15 @@ function createSocket(options) {
       socket = import_node_net.connect(options.port ?? 47891, options.host ?? "127.0.0.1", onConnect);
     }
     socket.on("error", onError);
-    const timeoutId = setTimeout(() => {
-      socket.destroy();
-      reject(new Error("Connection timeout"));
-    }, timeout);
-    socket.once("connect", () => {
-      clearTimeout(timeoutId);
-    });
+    if (timeout && timeout > 0) {
+      const timeoutId = setTimeout(() => {
+        socket.destroy();
+        reject(new Error("Connection timeout"));
+      }, timeout);
+      socket.once("connect", () => {
+        clearTimeout(timeoutId);
+      });
+    }
   });
 }
 function handleMessage(message, state) {
@@ -155,8 +253,6 @@ function handleMessage(message, state) {
       const pending = state.pendingRequests.get(response.requestId);
       if (pending) {
         state.pendingRequests.delete(response.requestId);
-        if (pending.timeoutId)
-          clearTimeout(pending.timeoutId);
         pending.resolve(response.data);
       }
       break;
@@ -166,8 +262,6 @@ function handleMessage(message, state) {
       const pending = state.pendingRequests.get(response.requestId);
       if (pending) {
         state.pendingRequests.delete(response.requestId);
-        if (pending.timeoutId)
-          clearTimeout(pending.timeoutId);
         const error = new Error(response.message);
         if (response.details) {
           error.name = response.details.name;
@@ -194,42 +288,9 @@ function handleMessage(message, state) {
       }
       break;
     }
-    case import_isolate_protocol.MessageType.WS_COMMAND: {
-      const msg = message;
-      const callbacks = isolateWsCallbacks.get(msg.isolateId);
-      if (callbacks) {
-        let data;
-        if (msg.command.data instanceof Uint8Array) {
-          data = msg.command.data.buffer.slice(msg.command.data.byteOffset, msg.command.data.byteOffset + msg.command.data.byteLength);
-        } else {
-          data = msg.command.data;
-        }
-        const cmd = {
-          type: msg.command.type,
-          connectionId: msg.command.connectionId,
-          data,
-          code: msg.command.code,
-          reason: msg.command.reason
-        };
-        for (const cb of callbacks) {
-          cb(cmd);
-        }
-      }
-      break;
-    }
-    case import_isolate_protocol.MessageType.CLIENT_WS_CONNECT: {
-      const msg = message;
-      handleClientWsConnect(msg, state);
-      break;
-    }
-    case import_isolate_protocol.MessageType.CLIENT_WS_SEND: {
+    case import_isolate_protocol.MessageType.ISOLATE_EVENT: {
       const msg = message;
-      handleClientWsSend(msg, state);
-      break;
-    }
-    case import_isolate_protocol.MessageType.CLIENT_WS_CLOSE: {
-      const msg = message;
-      handleClientWsClose(msg, state);
+      handleIsolateEvent(msg, state);
       break;
     }
     case import_isolate_protocol.MessageType.RESPONSE_STREAM_START: {
@@ -299,8 +360,6 @@ function handleMessage(message, state) {
       const pending = state.pendingRequests.get(msg.requestId);
       if (pending) {
         state.pendingRequests.delete(msg.requestId);
-        if (pending.timeoutId)
-          clearTimeout(pending.timeoutId);
         const response = new Response(readableStream, {
           status: msg.metadata?.status ?? 200,
           statusText: msg.metadata?.statusText ?? "OK",
@@ -425,25 +484,24 @@ function sendMessage(socket, message) {
   const frame = import_isolate_protocol.buildFrame(message);
   socket.write(frame);
 }
-function sendRequest(state, message, timeout = DEFAULT_TIMEOUT) {
+function sendRequest(state, message) {
   return new Promise((resolve, reject) => {
     if (!state.connected) {
       reject(new Error("Not connected"));
       return;
     }
     const requestId = message.requestId;
-    const timeoutId = setTimeout(() => {
-      state.pendingRequests.delete(requestId);
-      reject(new Error("Request timeout"));
-    }, timeout);
     state.pendingRequests.set(requestId, {
       resolve,
-      reject,
-      timeoutId
+      reject
     });
     sendMessage(state.socket, message);
   });
 }
+function isBenignDisposeError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /isolate not owned by this connection|isolate not found|not connected|connection closed/i.test(message);
+}
 async function createRuntime(state, options = {}, namespaceId) {
   const callbacks = {};
   if (options.console) {
@@ -582,13 +640,26 @@ async function createRuntime(state, options = {}, namespaceId) {
   const result = await sendRequest(state, request);
   const isolateId = result.isolateId;
   const reused = result.reused ?? false;
+  if (namespaceId != null) {
+    state.namespacedRuntimes.set(namespaceId, {
+      isolateId,
+      runtimeOptions: options
+    });
+  }
   const wsCommandCallbacks = new Set;
   isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
+  if (options.onWebSocketCommand) {
+    wsCommandCallbacks.add(options.onWebSocketCommand);
+  }
   if (options.webSocket) {
     isolateWebSocketCallbacks.set(isolateId, options.webSocket);
   }
   const fetchHandle = {
     async dispatchRequest(req, opts) {
+      const signal = opts?.signal;
+      if (signal?.aborted) {
+        throw new DOMException("The operation was aborted", "AbortError");
+      }
       const reqId = state.nextRequestId++;
       const serialized = await serializeRequestWithStreaming(state, req);
       const { bodyStream, ...serializableRequest } = serialized;
@@ -596,24 +667,40 @@ async function createRuntime(state, options = {}, namespaceId) {
         type: import_isolate_protocol.MessageType.DISPATCH_REQUEST,
         requestId: reqId,
         isolateId,
-        request: serializableRequest,
-        options: opts
+        request: serializableRequest
       };
       const handleResponse = (res) => {
         if (res.__streaming && res.response instanceof Response) {
           return res.response;
         }
-        return deserializeResponse(res.response);
+        return import_isolate_protocol.deserializeResponse(res.response);
       };
-      if (serialized.bodyStreamId !== undefined && bodyStream) {
-        const streamId = serialized.bodyStreamId;
-        const responsePromise = sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
-        await sendBodyStream(state, streamId, bodyStream);
-        const res = await responsePromise;
-        return handleResponse(res);
-      } else {
-        const res = await sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
-        return handleResponse(res);
+      let onAbort;
+      if (signal) {
+        onAbort = () => {
+          const pending = state.pendingRequests.get(reqId);
+          if (pending) {
+            state.pendingRequests.delete(reqId);
+            pending.reject(new DOMException("The operation was aborted", "AbortError"));
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      try {
+        if (serialized.bodyStreamId !== undefined && bodyStream) {
+          const streamId = serialized.bodyStreamId;
+          const responsePromise = sendRequest(state, request2);
+          await sendBodyStream(state, streamId, bodyStream);
+          const res = await responsePromise;
+          return handleResponse(res);
+        } else {
+          const res = await sendRequest(state, request2);
+          return handleResponse(res);
+        }
+      } finally {
+        if (signal && onAbort) {
+          signal.removeEventListener("abort", onAbort);
+        }
       }
     },
     async getUpgradeRequest() {
@@ -760,8 +847,22 @@ async function createRuntime(state, options = {}, namespaceId) {
         isolateId,
         timeout
       };
-      const requestTimeout = timeout === undefined ? DEFAULT_TIMEOUT : Math.max(timeout + TEST_REQUEST_TIMEOUT_BUFFER_MS, DEFAULT_TIMEOUT);
-      return sendRequest(state, req, requestTimeout);
+      try {
+        return await sendRequest(state, req);
+      } catch (err) {
+        if (err instanceof Error && /connection closed|not connected/i.test(err.message) && state.reconnecting) {
+          await state.reconnecting;
+          const retryReqId = state.nextRequestId++;
+          const retryReq = {
+            type: import_isolate_protocol.MessageType.RUN_TESTS,
+            requestId: retryReqId,
+            isolateId,
+            timeout
+          };
+          return sendRequest(state, retryReq);
+        }
+        throw err;
+      }
     },
     async hasTests() {
       if (!testEnvironmentEnabled) {
@@ -836,17 +937,47 @@ async function createRuntime(state, options = {}, namespaceId) {
         requestId: reqId,
         isolateId,
         code,
-        filename: options2?.filename,
-        maxExecutionMs: options2?.maxExecutionMs
+        filename: options2?.filename
       };
       await sendRequest(state, req);
     },
+    on(event, callback) {
+      let listeners = isolateEventListeners.get(isolateId);
+      if (!listeners) {
+        listeners = new Map;
+        isolateEventListeners.set(isolateId, listeners);
+      }
+      let eventListeners = listeners.get(event);
+      if (!eventListeners) {
+        eventListeners = new Set;
+        listeners.set(event, eventListeners);
+      }
+      eventListeners.add(callback);
+      return () => {
+        eventListeners.delete(callback);
+        if (eventListeners.size === 0) {
+          listeners.delete(event);
+          if (listeners.size === 0) {
+            isolateEventListeners.delete(isolateId);
+          }
+        }
+      };
+    },
+    emit(event, payload) {
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event,
+        payload
+      });
+    },
     dispose: async () => {
       for (const cleanup of pageListenerCleanups) {
         cleanup();
       }
       isolateWsCallbacks.delete(isolateId);
       isolateWebSocketCallbacks.delete(isolateId);
+      isolateEventListeners.delete(isolateId);
       const clientSockets = isolateClientWebSockets.get(isolateId);
       if (clientSockets) {
         for (const ws of clientSockets.values()) {
@@ -856,13 +987,22 @@ async function createRuntime(state, options = {}, namespaceId) {
         }
         isolateClientWebSockets.delete(isolateId);
       }
+      if (namespaceId != null) {
+        state.namespacedRuntimes.delete(namespaceId);
+      }
       const reqId = state.nextRequestId++;
       const req = {
         type: import_isolate_protocol.MessageType.DISPOSE_RUNTIME,
         requestId: reqId,
         isolateId
       };
-      await sendRequest(state, req);
+      try {
+        await sendRequest(state, req);
+      } catch (error) {
+        if (!isBenignDisposeError(error)) {
+          throw error;
+        }
+      }
     }
   };
 }
@@ -894,8 +1034,8 @@ function registerFetchCallback(state, callback) {
     const init = {
       method: data.method,
       headers: data.headers,
-      rawBody: data.body,
-      body: data.body,
+      rawBody: data.body ?? null,
+      body: data.body ?? null,
       signal: new AbortController().signal
     };
     const response = await callback(data.url, init);
@@ -923,7 +1063,7 @@ function registerFetchCallback(state, callback) {
       streamCallbackResponseBody(state, streamId, requestId, response.body);
       return { __callbackStreaming: true, streamId };
     }
-    return serializeResponse(response);
+    return import_isolate_protocol.serializeResponse(response);
   });
   return { callbackId, name: "fetch", type: "async" };
 }
@@ -1041,7 +1181,7 @@ function registerModuleLoaderCallback(state, callback) {
     const specifier = moduleName;
     const importerInfo = importer;
     const result = await callback(specifier, importerInfo);
-    const resolvedPath = import_node_path.default.posix.join(result.resolveDir, import_node_path.default.posix.basename(specifier));
+    const resolvedPath = import_node_path.default.posix.join(result.resolveDir, result.filename);
     state.moduleSourceCache.set(resolvedPath, result.code);
     return result;
   });
@@ -1051,12 +1191,6 @@ var clientIteratorSessions = new Map;
 var nextClientIteratorId = 1;
 var returnedPromiseRegistry = new Map;
 var returnedIteratorRegistry = new Map;
-function isPromiseRef(value) {
-  return typeof value === "object" && value !== null && value.__type === "PromiseRef";
-}
-function isAsyncIteratorRef(value) {
-  return typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
-}
 function registerCustomFunctions(state, customFunctions) {
   const registrations = {};
   for (const [name, def] of Object.entries(customFunctions)) {
@@ -1139,7 +1273,7 @@ function registerCustomFunctions(state, customFunctions) {
           if (value === null || typeof value !== "object") {
             return value;
           }
-          if (isPromiseRef(value)) {
+          if (import_isolate_protocol.isPromiseRef(value)) {
             const resolveCallbackId = state.nextCallbackId++;
             state.callbacks.set(resolveCallbackId, async (...args2) => {
               const promiseId = args2[0];
@@ -1157,7 +1291,7 @@ function registerCustomFunctions(state, customFunctions) {
               __resolveCallbackId: resolveCallbackId
             };
           }
-          if (isAsyncIteratorRef(value)) {
+          if (import_isolate_protocol.isAsyncIteratorRef(value)) {
             const nextCallbackId = state.nextCallbackId++;
             state.callbacks.set(nextCallbackId, async (...args2) => {
               const iteratorId = args2[0];
@@ -1240,29 +1374,6 @@ function registerCustomFunctions(state, customFunctions) {
   }
   return registrations;
 }
-async function serializeResponse(response) {
-  const headers = [];
-  response.headers.forEach((value, key) => {
-    headers.push([key, value]);
-  });
-  let body = null;
-  if (response.body) {
-    body = new Uint8Array(await response.arrayBuffer());
-  }
-  return {
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-    body
-  };
-}
-function deserializeResponse(data) {
-  return new Response(data.body, {
-    status: data.status,
-    statusText: data.statusText,
-    headers: data.headers
-  });
-}
 async function serializeRequestWithStreaming(state, request) {
   const headers = [];
   request.headers.forEach((value, key) => {
@@ -1361,8 +1472,62 @@ async function sendBodyStream(state, streamId, body) {
     state.uploadStreams.delete(streamId);
   }
 }
-function handleClientWsConnect(message, state) {
-  const { isolateId, socketId, url, protocols } = message;
+function handleIsolateEvent(message, state) {
+  switch (message.event) {
+    case import_isolate_protocol.IsolateEvents.WS_COMMAND: {
+      const payload = message.payload;
+      const callbacks = isolateWsCallbacks.get(message.isolateId);
+      if (callbacks) {
+        let data;
+        if (payload.data instanceof Uint8Array) {
+          data = payload.data.buffer.slice(payload.data.byteOffset, payload.data.byteOffset + payload.data.byteLength);
+        } else {
+          data = payload.data;
+        }
+        const cmd = {
+          type: payload.type,
+          connectionId: payload.connectionId,
+          data,
+          code: payload.code,
+          reason: payload.reason
+        };
+        for (const cb of callbacks) {
+          cb(cmd);
+        }
+      }
+      break;
+    }
+    case import_isolate_protocol.IsolateEvents.WS_CLIENT_CONNECT: {
+      const payload = message.payload;
+      handleClientWsConnect(message.isolateId, payload, state);
+      break;
+    }
+    case import_isolate_protocol.IsolateEvents.WS_CLIENT_SEND: {
+      const payload = message.payload;
+      handleClientWsSend(message.isolateId, payload, state);
+      break;
+    }
+    case import_isolate_protocol.IsolateEvents.WS_CLIENT_CLOSE: {
+      const payload = message.payload;
+      handleClientWsClose(message.isolateId, payload, state);
+      break;
+    }
+    default: {
+      const listeners = isolateEventListeners.get(message.isolateId);
+      if (listeners) {
+        const eventListeners = listeners.get(message.event);
+        if (eventListeners) {
+          for (const cb of eventListeners) {
+            cb(message.payload);
+          }
+        }
+      }
+      break;
+    }
+  }
+}
+function handleClientWsConnect(isolateId, payload, state) {
+  const { socketId, url, protocols } = payload;
   let sockets = isolateClientWebSockets.get(isolateId);
   if (!sockets) {
     sockets = new Map;
@@ -1371,14 +1536,12 @@ function handleClientWsConnect(message, state) {
   const setupWebSocket = (ws) => {
     sockets.set(socketId, ws);
     ws.onopen = () => {
-      const msg = {
-        type: import_isolate_protocol.MessageType.CLIENT_WS_OPENED,
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.CLIENT_EVENT,
         isolateId,
-        socketId,
-        protocol: ws.protocol || "",
-        extensions: ws.extensions || ""
-      };
-      sendMessage(state.socket, msg);
+        event: import_isolate_protocol.ClientEvents.WS_CLIENT_OPENED,
+        payload: { socketId, protocol: ws.protocol || "", extensions: ws.extensions || "" }
+      });
     };
     ws.onmessage = (event) => {
       let data;
@@ -1388,44 +1551,39 @@ function handleClientWsConnect(message, state) {
         data = new Uint8Array(event.data);
       } else if (event.data instanceof Blob) {
         event.data.arrayBuffer().then((buffer) => {
-          const msg2 = {
-            type: import_isolate_protocol.MessageType.CLIENT_WS_MESSAGE,
+          sendMessage(state.socket, {
+            type: import_isolate_protocol.MessageType.CLIENT_EVENT,
             isolateId,
-            socketId,
-            data: new Uint8Array(buffer)
-          };
-          sendMessage(state.socket, msg2);
+            event: import_isolate_protocol.ClientEvents.WS_CLIENT_MESSAGE,
+            payload: { socketId, data: new Uint8Array(buffer) }
+          });
         });
         return;
       } else {
         data = String(event.data);
       }
-      const msg = {
-        type: import_isolate_protocol.MessageType.CLIENT_WS_MESSAGE,
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.CLIENT_EVENT,
         isolateId,
-        socketId,
-        data
-      };
-      sendMessage(state.socket, msg);
+        event: import_isolate_protocol.ClientEvents.WS_CLIENT_MESSAGE,
+        payload: { socketId, data }
+      });
     };
     ws.onerror = () => {
-      const msg = {
-        type: import_isolate_protocol.MessageType.CLIENT_WS_ERROR,
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.CLIENT_EVENT,
         isolateId,
-        socketId
-      };
-      sendMessage(state.socket, msg);
+        event: import_isolate_protocol.ClientEvents.WS_CLIENT_ERROR,
+        payload: { socketId }
+      });
     };
     ws.onclose = (event) => {
-      const msg = {
-        type: import_isolate_protocol.MessageType.CLIENT_WS_CLOSED,
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.CLIENT_EVENT,
         isolateId,
-        socketId,
-        code: event.code,
-        reason: event.reason,
-        wasClean: event.wasClean
-      };
-      sendMessage(state.socket, msg);
+        event: import_isolate_protocol.ClientEvents.WS_CLIENT_CLOSED,
+        payload: { socketId, code: event.code, reason: event.reason, wasClean: event.wasClean }
+      });
       sockets?.delete(socketId);
       if (sockets?.size === 0) {
         isolateClientWebSockets.delete(isolateId);
@@ -1433,21 +1591,18 @@ function handleClientWsConnect(message, state) {
     };
   };
   const sendConnectionFailed = (reason) => {
-    const errorMsg = {
-      type: import_isolate_protocol.MessageType.CLIENT_WS_ERROR,
+    sendMessage(state.socket, {
+      type: import_isolate_protocol.MessageType.CLIENT_EVENT,
       isolateId,
-      socketId
-    };
-    sendMessage(state.socket, errorMsg);
-    const closeMsg = {
-      type: import_isolate_protocol.MessageType.CLIENT_WS_CLOSED,
+      event: import_isolate_protocol.ClientEvents.WS_CLIENT_ERROR,
+      payload: { socketId }
+    });
+    sendMessage(state.socket, {
+      type: import_isolate_protocol.MessageType.CLIENT_EVENT,
       isolateId,
-      socketId,
-      code: 1006,
-      reason,
-      wasClean: false
-    };
-    sendMessage(state.socket, closeMsg);
+      event: import_isolate_protocol.ClientEvents.WS_CLIENT_CLOSED,
+      payload: { socketId, code: 1006, reason, wasClean: false }
+    });
   };
   const callback = isolateWebSocketCallbacks.get(isolateId);
   if (callback) {
@@ -1480,8 +1635,8 @@ function handleClientWsConnect(message, state) {
     }
   }
 }
-function handleClientWsSend(message, state) {
-  const { isolateId, socketId, data } = message;
+function handleClientWsSend(isolateId, payload, state) {
+  const { socketId, data } = payload;
   const sockets = isolateClientWebSockets.get(isolateId);
   const ws = sockets?.get(socketId);
   if (!ws || ws.readyState !== WebSocket.OPEN) {
@@ -1492,13 +1647,13 @@ function handleClientWsSend(message, state) {
     const binary = Buffer.from(base64, "base64");
     ws.send(binary);
   } else if (data instanceof Uint8Array) {
-    ws.send(data);
+    ws.send(Buffer.from(data));
   } else {
     ws.send(data);
   }
 }
-function handleClientWsClose(message, state) {
-  const { isolateId, socketId, code, reason } = message;
+function handleClientWsClose(isolateId, payload, state) {
+  const { socketId, code, reason } = payload;
   const sockets = isolateClientWebSockets.get(isolateId);
   const ws = sockets?.get(socketId);
   if (!ws) {
@@ -1509,4 +1664,4 @@ function handleClientWsClose(message, state) {
   }
 }
 
-//# debugId=7A85E05BA8CAD49764756E2164756E21
+//# debugId=BB5A27475A32C8E264756E2164756E21