@ricsam/isolate-daemon 0.1.14 → 0.1.16

package/dist/cjs/connection.cjs

@@ -36,6 +36,28 @@ var import_node_crypto = require("node:crypto");
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_callback_fs_handler = require("./callback-fs-handler.cjs");
 var import_isolate_runtime = require("@ricsam/isolate-runtime");
+var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
+function getErrorText(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    const causeText = cause instanceof Error ? `${cause.name}: ${cause.message}
+${cause.stack ?? ""}` : cause != null ? String(cause) : "";
+    return [error.name, error.message, error.stack, causeText].filter((part) => part != null && part !== "").join(`
+`);
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error ?? "");
+  }
+}
+function isLinkerConflictError(error) {
+  const text = getErrorText(error).toLowerCase();
+  return text.includes(LINKER_CONFLICT_ERROR.toLowerCase());
+}
 function handleConnection(socket, state) {
   const connection = {
     socket,
@@ -68,17 +90,17 @@ function handleConnection(socket, state) {
       const instance = state.isolates.get(isolateId);
       if (instance) {
         if (instance.namespaceId != null && !instance.isDisposed) {
-          softDeleteRuntime(instance, state);
+          if (instance.isPoisoned) {
+            hardDeleteRuntime(instance, state).catch(() => {});
+          } else {
+            softDeleteRuntime(instance, state);
+          }
         } else if (!instance.isDisposed) {
-          instance.runtime.dispose().catch(() => {});
-          state.isolates.delete(isolateId);
+          hardDeleteRuntime(instance, state).catch(() => {});
         }
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
-      if (pending.timeoutId) {
-        clearTimeout(pending.timeoutId);
-      }
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -206,28 +228,64 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.CALLBACK_STREAM_END:
       handleCallbackStreamEnd(message, connection);
       break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_OPENED:
-      handleClientWsOpened(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_MESSAGE:
-      handleClientWsMessage(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_CLOSED:
-      handleClientWsClosed(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_ERROR:
-      handleClientWsError(message, connection, state);
+    case import_isolate_protocol.MessageType.CLIENT_EVENT:
+      handleClientEvent(message, connection, state);
       break;
     default:
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
 }
+async function hardDeleteRuntime(instance, state) {
+  try {
+    await instance.runtime.dispose();
+  } finally {
+    state.isolates.delete(instance.isolateId);
+    if (instance.namespaceId != null) {
+      const indexed = state.namespacedRuntimes.get(instance.namespaceId);
+      if (indexed?.isolateId === instance.isolateId) {
+        state.namespacedRuntimes.delete(instance.namespaceId);
+      }
+    }
+    instance.isDisposed = true;
+    instance.disposedAt = undefined;
+    instance.ownerConnection = null;
+    if (instance.callbackContext) {
+      if (instance.callbackContext.reconnectionPromise) {
+        clearTimeout(instance.callbackContext.reconnectionPromise.timeoutId);
+        instance.callbackContext.reconnectionPromise.promise.catch(() => {});
+        instance.callbackContext.reconnectionPromise.reject(new Error("Runtime was permanently disposed"));
+        instance.callbackContext.reconnectionPromise = undefined;
+      }
+      instance.callbackContext.connection = null;
+    }
+  }
+}
+var RECONNECTION_TIMEOUT_MS = 30000;
 function softDeleteRuntime(instance, state) {
   instance.isDisposed = true;
   instance.disposedAt = Date.now();
   instance.ownerConnection = null;
   if (instance.callbackContext) {
     instance.callbackContext.connection = null;
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    promise.catch(() => {});
+    const timeoutId = setTimeout(() => {
+      if (instance.callbackContext?.reconnectionPromise) {
+        instance.callbackContext.reconnectionPromise = undefined;
+        reject(new Error("Reconnection timeout: no client reconnected within timeout"));
+      }
+    }, RECONNECTION_TIMEOUT_MS);
+    instance.callbackContext.reconnectionPromise = {
+      promise,
+      resolve,
+      reject,
+      timeoutId
+    };
   }
   instance.callbacks.clear();
   instance.runtime.timers.clearAll();
@@ -241,6 +299,7 @@ function softDeleteRuntime(instance, state) {
 function reuseNamespacedRuntime(instance, connection, message, state) {
   instance.ownerConnection = connection.socket;
   instance.isDisposed = false;
+  instance.isPoisoned = false;
   instance.disposedAt = undefined;
   instance.lastActivity = Date.now();
   connection.isolates.add(instance.isolateId);
@@ -248,6 +307,11 @@ function reuseNamespacedRuntime(instance, connection, message, state) {
   const testEnvOptions = message.options.testEnvironment != null && typeof message.options.testEnvironment === "object" ? message.options.testEnvironment : undefined;
   if (instance.callbackContext) {
     instance.callbackContext.connection = connection;
+    if (instance.callbackContext.reconnectionPromise) {
+      clearTimeout(instance.callbackContext.reconnectionPromise.timeoutId);
+      instance.callbackContext.reconnectionPromise.resolve(connection);
+      instance.callbackContext.reconnectionPromise = undefined;
+    }
     instance.callbackContext.consoleOnEntry = callbacks?.console?.onEntry?.callbackId;
     instance.callbackContext.fetch = callbacks?.fetch?.callbackId;
     instance.callbackContext.moduleLoader = callbacks?.moduleLoader?.callbackId;
@@ -342,6 +406,35 @@ function reuseNamespacedRuntime(instance, connection, message, state) {
   instance.returnedIterators = new Map;
   instance.nextLocalCallbackId = 1e6;
 }
+async function waitForConnection(callbackContext) {
+  if (callbackContext.connection) {
+    return callbackContext.connection;
+  }
+  if (callbackContext.reconnectionPromise) {
+    return callbackContext.reconnectionPromise.promise;
+  }
+  throw new Error("No connection available and no reconnection pending");
+}
+async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback) {
+  const conn = await waitForConnection(callbackContext);
+  const cbId = getCallbackId();
+  if (cbId === undefined) {
+    throw new Error(`${label} callback not available`);
+  }
+  try {
+    return await invokeClientCallback(conn, cbId, args);
+  } catch (err) {
+    if (callbackContext.reconnectionPromise && !callbackContext.connection) {
+      const newConn = await callbackContext.reconnectionPromise.promise;
+      const newCbId = getCallbackId();
+      if (newCbId === undefined) {
+        throw new Error(`${label} callback not available after reconnection`);
+      }
+      return invokeClientCallback(newConn, newCbId, args);
+    }
+    throw err;
+  }
+}
 async function evictOldestDisposedRuntime(state) {
   let oldest = null;
   let oldestTime = Infinity;
@@ -355,18 +448,15 @@ async function evictOldestDisposedRuntime(state) {
   }
   if (oldest) {
     try {
-      await oldest.runtime.dispose();
+      await hardDeleteRuntime(oldest, state);
     } catch {}
-    state.isolates.delete(oldest.isolateId);
-    if (oldest.namespaceId != null) {
-      state.namespacedRuntimes.delete(oldest.namespaceId);
-    }
     return true;
   }
   return false;
 }
 async function handleCreateRuntime(message, connection, state) {
   const namespaceId = message.options.namespaceId;
+  let namespaceCreationLocked = false;
   if (namespaceId != null) {
     const existing = state.namespacedRuntimes.get(namespaceId);
     if (existing) {
@@ -388,14 +478,20 @@ async function handleCreateRuntime(message, connection, state) {
       });
       return;
     }
-  }
-  if (state.isolates.size >= state.options.maxIsolates) {
-    if (!await evictOldestDisposedRuntime(state)) {
-      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+    if (state.namespacedCreatesInFlight.has(namespaceId)) {
+      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, `Namespace "${namespaceId}" creation already in progress`);
       return;
     }
+    state.namespacedCreatesInFlight.add(namespaceId);
+    namespaceCreationLocked = true;
   }
   try {
+    if (state.isolates.size >= state.options.maxIsolates) {
+      if (!await evictOldestDisposedRuntime(state)) {
+        sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+        return;
+      }
+    }
     const isolateId = import_node_crypto.randomUUID();
     const consoleCallbacks = message.options.callbacks?.console;
     const fetchCallback = message.options.callbacks?.fetch;
@@ -438,6 +534,7 @@ async function handleCreateRuntime(message, connection, state) {
       nextLocalCallbackId: 1e6,
       namespaceId,
       isDisposed: false,
+      isPoisoned: false,
       callbackContext
     };
     let bridgedCustomFunctions;
@@ -460,12 +557,10 @@ async function handleCreateRuntime(message, connection, state) {
           return iteratorId;
         }
       });
-      const isPromiseRef = (value) => typeof value === "object" && value !== null && value.__type === "PromiseRef";
-      const isAsyncIteratorRef = (value) => typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
       const addCallbackIdsToRefs = (value) => {
         if (value === null || typeof value !== "object")
           return value;
-        if (isPromiseRef(value)) {
+        if (import_isolate_protocol.isPromiseRef(value)) {
           if ("__resolveCallbackId" in value)
             return value;
           const resolveCallbackId = instance.nextLocalCallbackId++;
@@ -481,7 +576,7 @@ async function handleCreateRuntime(message, connection, state) {
           });
           return { ...value, __resolveCallbackId: resolveCallbackId };
         }
-        if (isAsyncIteratorRef(value)) {
+        if (import_isolate_protocol.isAsyncIteratorRef(value)) {
           if ("__nextCallbackId" in value)
             return value;
           const nextCallbackId = instance.nextLocalCallbackId++;
@@ -526,11 +621,16 @@ async function handleCreateRuntime(message, connection, state) {
           }
           return await callback(...args);
         } else {
-          const conn = callbackContext.connection;
-          if (!conn) {
-            throw new Error(`No connection available for callback ${callbackId}`);
+          const conn = await waitForConnection(callbackContext);
+          try {
+            return await invokeClientCallback(conn, callbackId, args);
+          } catch (err) {
+            if (callbackContext.reconnectionPromise && !callbackContext.connection) {
+              const newConn = await callbackContext.reconnectionPromise.promise;
+              return invokeClientCallback(newConn, callbackId, args);
+            }
+            throw err;
           }
-          return invokeClientCallback(conn, callbackId, args);
         }
       };
       customFnMarshalOptions = { createMarshalContext, addCallbackIdsToRefs, invokeCallback };
@@ -547,27 +647,20 @@ async function handleCreateRuntime(message, connection, state) {
               const nextCallbackId = callbackContext_.custom.get(`${name}:next`);
               const returnCallbackId = callbackContext_.custom.get(`${name}:return`);
               async function* bridgedIterator() {
-                const conn = callbackContext_.connection;
-                if (!conn || startCallbackId === undefined) {
-                  throw new Error(`AsyncIterator callback '${name}' not available`);
-                }
-                const startResult = await invokeClientCallback(conn, startCallbackId, args);
+                const startResult = await invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(`${name}:start`), args, `AsyncIterator '${name}' start`, invokeClientCallback);
                 const iteratorId = startResult.iteratorId;
                 try {
                   while (true) {
-                    const nextConn = callbackContext_.connection;
-                    if (!nextConn || nextCallbackId === undefined) {
-                      throw new Error(`AsyncIterator callback '${name}' not available`);
-                    }
-                    const nextResult = await invokeClientCallback(nextConn, nextCallbackId, [iteratorId]);
+                    const nextResult = await invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(`${name}:next`), [iteratorId], `AsyncIterator '${name}' next`, invokeClientCallback);
                     if (nextResult.done)
                       return nextResult.value;
                     yield nextResult.value;
                   }
                 } finally {
                   const retConn = callbackContext_.connection;
-                  if (retConn && returnCallbackId !== undefined) {
-                    await invokeClientCallback(retConn, returnCallbackId, [iteratorId]).catch(() => {});
+                  const retCbId = callbackContext_.custom.get(`${name}:return`);
+                  if (retConn && retCbId !== undefined) {
+                    await invokeClientCallback(retConn, retCbId, [iteratorId]).catch(() => {});
                   }
                 }
               }
@@ -578,12 +671,7 @@ async function handleCreateRuntime(message, connection, state) {
           bridgedCustomFunctions[name] = {
             type: registration.type,
             fn: async (...args) => {
-              const conn = callbackContext_.connection;
-              const cbId = callbackContext_.custom.get(name);
-              if (!conn || cbId === undefined) {
-                throw new Error(`Custom function callback '${name}' not available`);
-              }
-              return invokeClientCallback(conn, cbId, args);
+              return invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(name), args, `Custom function '${name}'`, invokeClientCallback);
             }
           };
         }
@@ -592,12 +680,7 @@ async function handleCreateRuntime(message, connection, state) {
     let moduleLoader;
     if (moduleLoaderCallback) {
       moduleLoader = async (specifier, importer) => {
-        const conn = callbackContext.connection;
-        const cbId = callbackContext.moduleLoader;
-        if (!conn || cbId === undefined) {
-          throw new Error("Module loader callback not available");
-        }
-        return invokeClientCallback(conn, cbId, [specifier, importer]);
+        return invokeCallbackWithReconnect(callbackContext, () => callbackContext.moduleLoader, [specifier, importer], "Module loader", invokeClientCallback);
       };
     }
     let testEnvironment;
@@ -628,19 +711,8 @@ async function handleCreateRuntime(message, connection, state) {
     if (playwrightCallbacks) {
       playwrightOptions = {
         handler: async (op) => {
-          const conn = callbackContext.connection;
-          const callbackId = callbackContext.playwright.handlerCallbackId;
-          if (!conn || callbackId === undefined) {
-            return {
-              ok: false,
-              error: {
-                name: "Error",
-                message: "Playwright handler callback not available"
-              }
-            };
-          }
           try {
-            const resultJson = await invokeClientCallback(conn, callbackId, [JSON.stringify(op)], 60000);
+            const resultJson = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.playwright.handlerCallbackId, [JSON.stringify(op)], "Playwright handler", invokeClientCallback);
             return JSON.parse(resultJson);
           } catch (err) {
             const error = err;
@@ -680,31 +752,23 @@ async function handleCreateRuntime(message, connection, state) {
         }
       },
       fetch: async (url, init) => {
-        const conn = callbackContext.connection;
-        const callbackId = callbackContext.fetch;
-        if (!conn || callbackId === undefined) {
-          throw new Error("Fetch callback not available");
-        }
         const serialized = {
           url,
           method: init.method,
           headers: init.headers,
           body: init.rawBody
         };
-        const result = await invokeClientCallback(conn, callbackId, [serialized], 60000);
+        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback);
         if (result && typeof result === "object" && result.__streamingResponse) {
           const response = result.response;
           response.__isCallbackStream = true;
           return response;
         }
-        return deserializeResponse(result);
+        return import_isolate_protocol.deserializeResponse(result);
       },
       fs: {
         getDirectory: async (dirPath) => {
-          const conn = callbackContext.connection;
-          if (!conn) {
-            throw new Error("FS callbacks not available");
-          }
+          const conn = await waitForConnection(callbackContext);
           return import_callback_fs_handler.createCallbackFileSystemHandler({
             connection: conn,
             callbackContext,
@@ -791,18 +855,19 @@ async function handleCreateRuntime(message, connection, state) {
       } else {
         data = cmd.data;
       }
-      const wsCommandMsg = {
-        type: import_isolate_protocol.MessageType.WS_COMMAND,
-        isolateId,
-        command: {
-          type: cmd.type,
-          connectionId: cmd.connectionId,
-          data,
-          code: cmd.code,
-          reason: cmd.reason
-        }
+      const payload = {
+        type: cmd.type,
+        connectionId: cmd.connectionId,
+        data,
+        code: cmd.code,
+        reason: cmd.reason
       };
-      sendMessage(targetConnection.socket, wsCommandMsg);
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: import_isolate_protocol.IsolateEvents.WS_COMMAND,
+        payload
+      });
     });
     runtime.fetch.onClientWebSocketCommand((cmd) => {
       const targetConnection = callbackContext.connection;
@@ -816,40 +881,62 @@ async function handleCreateRuntime(message, connection, state) {
         data = cmd.data;
       }
       if (cmd.type === "connect") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_CONNECT,
-          requestId: 0,
-          isolateId,
+        const payload = {
           socketId: cmd.socketId,
           url: cmd.url,
           protocols: cmd.protocols
         };
-        sendMessage(targetConnection.socket, msg);
-      } else if (cmd.type === "send") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_SEND,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
           isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CONNECT,
+          payload
+        });
+      } else if (cmd.type === "send") {
+        const payload = {
           socketId: cmd.socketId,
           data
         };
-        sendMessage(targetConnection.socket, msg);
-      } else if (cmd.type === "close") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_CLOSE,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
           isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_SEND,
+          payload
+        });
+      } else if (cmd.type === "close") {
+        const payload = {
           socketId: cmd.socketId,
           code: cmd.code,
           reason: cmd.reason
         };
-        sendMessage(targetConnection.socket, msg);
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CLOSE,
+          payload
+        });
       }
     });
+    runtime.fetch.onEvent((eventName, payload) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: eventName,
+        payload
+      });
+    });
     sendOk(connection.socket, message.requestId, { isolateId, reused: false });
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  } finally {
+    if (namespaceCreationLocked && namespaceId != null) {
+      state.namespacedCreatesInFlight.delete(namespaceId);
+    }
   }
 }
 async function handleDisposeRuntime(message, connection, state) {
@@ -865,14 +952,20 @@ async function handleDisposeRuntime(message, connection, state) {
   try {
     connection.isolates.delete(message.isolateId);
     if (instance.namespaceId != null) {
-      softDeleteRuntime(instance, state);
+      if (instance.isPoisoned) {
+        await hardDeleteRuntime(instance, state);
+      } else {
+        softDeleteRuntime(instance, state);
+      }
     } else {
-      await instance.runtime.dispose();
-      state.isolates.delete(message.isolateId);
+      await hardDeleteRuntime(instance, state);
     }
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -885,14 +978,15 @@ async function handleEval(message, connection, state) {
   instance.lastActivity = Date.now();
   try {
     await instance.runtime.eval(message.code, {
-      filename: message.filename,
-      maxExecutionMs: message.maxExecutionMs
+      filename: message.filename
     });
     sendOk(connection.socket, message.requestId, { value: undefined });
   } catch (err) {
     const error = err;
-    const isTimeoutError = error.message?.includes("Script execution timed out");
-    sendError(connection.socket, message.requestId, isTimeoutError ? import_isolate_protocol.ErrorCode.ISOLATE_TIMEOUT : import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleDispatchRequest(message, connection, state) {
@@ -1000,34 +1094,38 @@ async function handleWsClose(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-function handleClientWsOpened(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketOpen(message.socketId, message.protocol, message.extensions);
-}
-function handleClientWsMessage(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  const data = message.data instanceof Uint8Array ? message.data.buffer.slice(message.data.byteOffset, message.data.byteOffset + message.data.byteLength) : message.data;
-  instance.runtime.fetch.dispatchClientWebSocketMessage(message.socketId, data);
-}
-function handleClientWsClosed(message, connection, state) {
+function handleClientEvent(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance)
     return;
   instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketClose(message.socketId, message.code, message.reason, message.wasClean);
-}
-function handleClientWsError(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketError(message.socketId);
+  switch (message.event) {
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_OPENED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketOpen(payload.socketId, payload.protocol, payload.extensions);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_MESSAGE: {
+      const payload = message.payload;
+      const data = payload.data instanceof Uint8Array ? payload.data.buffer.slice(payload.data.byteOffset, payload.data.byteOffset + payload.data.byteLength) : payload.data;
+      instance.runtime.fetch.dispatchClientWebSocketMessage(payload.socketId, data);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_CLOSED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketClose(payload.socketId, payload.code, payload.reason, payload.wasClean);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_ERROR: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketError(payload.socketId);
+      break;
+    }
+    default: {
+      instance.runtime.fetch.dispatchEvent(message.event, message.payload);
+      break;
+    }
+  }
 }
 async function handleFetchGetUpgradeRequest(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
@@ -1171,9 +1269,6 @@ function handleCallbackResponse(message, connection) {
     return;
   }
   connection.pendingCallbacks.delete(message.requestId);
-  if (pending.timeoutId) {
-    clearTimeout(pending.timeoutId);
-  }
   if (message.error) {
     const error = new Error(message.error.message);
     error.name = message.error.name;
@@ -1185,17 +1280,12 @@ function handleCallbackResponse(message, connection) {
     pending.resolve(message.result);
   }
 }
-async function invokeClientCallback(connection, callbackId, args, timeout = 1e4) {
+async function invokeClientCallback(connection, callbackId, args) {
   const requestId = connection.nextCallbackId++;
   return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      connection.pendingCallbacks.delete(requestId);
-      reject(new Error("Callback timeout"));
-    }, timeout);
     const pending = {
       resolve,
-      reject,
-      timeoutId
+      reject
     };
     connection.pendingCallbacks.set(requestId, pending);
     const invoke = {
@@ -1207,13 +1297,6 @@ async function invokeClientCallback(connection, callbackId, args, timeout = 1e4)
     sendMessage(connection.socket, invoke);
   });
 }
-function deserializeResponse(data) {
-  return new Response(data.body, {
-    status: data.status,
-    statusText: data.statusText,
-    headers: data.headers
-  });
-}
 function handleStreamPush(message, connection) {
   const receiver = connection.streamReceivers.get(message.streamId);
   if (!receiver) {
@@ -1341,9 +1424,6 @@ function handleCallbackStreamStart(message, connection) {
   const pending = connection.pendingCallbacks.get(message.requestId);
   if (pending) {
     connection.pendingCallbacks.delete(message.requestId);
-    if (pending.timeoutId) {
-      clearTimeout(pending.timeoutId);
-    }
     const response = new Response(readableStream, {
       status: message.metadata.status,
       statusText: message.metadata.statusText,
@@ -1474,13 +1554,35 @@ async function handleRunTests(message, connection, state) {
     return;
   }
   instance.lastActivity = Date.now();
+  if (instance.pendingTestRun) {
+    try {
+      const results = await instance.pendingTestRun.promise;
+      const currentConn = instance.callbackContext?.connection;
+      if (currentConn) {
+        sendOk(currentConn.socket, message.requestId, results);
+      }
+    } catch (err) {
+      const error = err;
+      const currentConn = instance.callbackContext?.connection;
+      if (currentConn) {
+        sendError(currentConn.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+      }
+    }
+    return;
+  }
   try {
     const timeout = message.timeout ?? 30000;
-    const results = await instance.runtime.testEnvironment.runTests(timeout);
-    sendOk(connection.socket, message.requestId, results);
+    const runPromise = instance.runtime.testEnvironment.runTests(timeout);
+    instance.pendingTestRun = { promise: runPromise };
+    const results = await runPromise;
+    instance.pendingTestRun = undefined;
+    const currentConn = instance.callbackContext?.connection ?? connection;
+    sendOk(currentConn.socket, message.requestId, results);
   } catch (err) {
+    instance.pendingTestRun = undefined;
     const error = err;
-    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    const currentConn = instance.callbackContext?.connection ?? connection;
+    sendError(currentConn.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleResetTestEnv(message, connection, state) {
@@ -1559,4 +1661,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=53A5FD566727ACE764756E2164756E21
+//# debugId=D9712A3ECDBAF18B64756E2164756E21