@ricsam/isolate-daemon 0.1.14 → 0.1.16

package/dist/mjs/connection.mjs

@@ -7,12 +7,39 @@ import {
   ErrorCode,
   STREAM_CHUNK_SIZE,
   STREAM_DEFAULT_CREDIT,
-  marshalValue
+  marshalValue,
+  isPromiseRef,
+  isAsyncIteratorRef,
+  deserializeResponse,
+  IsolateEvents,
+  ClientEvents
 } from "@ricsam/isolate-protocol";
 import { createCallbackFileSystemHandler } from "./callback-fs-handler.mjs";
 import {
   createRuntime
 } from "@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,
@@ -45,17 +72,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();
@@ -183,28 +210,64 @@ async function handleMessage(message, connection, state) {
     case MessageType.CALLBACK_STREAM_END:
       handleCallbackStreamEnd(message, connection);
       break;
-    case MessageType.CLIENT_WS_OPENED:
-      handleClientWsOpened(message, connection, state);
-      break;
-    case MessageType.CLIENT_WS_MESSAGE:
-      handleClientWsMessage(message, connection, state);
-      break;
-    case MessageType.CLIENT_WS_CLOSED:
-      handleClientWsClosed(message, connection, state);
-      break;
-    case MessageType.CLIENT_WS_ERROR:
-      handleClientWsError(message, connection, state);
+    case MessageType.CLIENT_EVENT:
+      handleClientEvent(message, connection, state);
       break;
     default:
       sendError(connection.socket, message.requestId ?? 0, 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();
@@ -218,6 +281,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);
@@ -225,6 +289,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;
@@ -319,6 +388,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;
@@ -332,18 +430,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) {
@@ -365,14 +460,20 @@ async function handleCreateRuntime(message, connection, state) {
       });
       return;
     }
-  }
-  if (state.isolates.size >= state.options.maxIsolates) {
-    if (!await evictOldestDisposedRuntime(state)) {
-      sendError(connection.socket, message.requestId, ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+    if (state.namespacedCreatesInFlight.has(namespaceId)) {
+      sendError(connection.socket, message.requestId, 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, ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+        return;
+      }
+    }
     const isolateId = randomUUID();
     const consoleCallbacks = message.options.callbacks?.console;
     const fetchCallback = message.options.callbacks?.fetch;
@@ -415,6 +516,7 @@ async function handleCreateRuntime(message, connection, state) {
       nextLocalCallbackId: 1e6,
       namespaceId,
       isDisposed: false,
+      isPoisoned: false,
       callbackContext
     };
     let bridgedCustomFunctions;
@@ -437,8 +539,6 @@ 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;
@@ -503,11 +603,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 };
@@ -524,27 +629,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(() => {});
                   }
                 }
               }
@@ -555,12 +653,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);
             }
           };
         }
@@ -569,12 +662,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;
@@ -605,19 +693,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;
@@ -657,18 +734,13 @@ 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;
@@ -678,10 +750,7 @@ async function handleCreateRuntime(message, connection, state) {
       },
       fs: {
         getDirectory: async (dirPath) => {
-          const conn = callbackContext.connection;
-          if (!conn) {
-            throw new Error("FS callbacks not available");
-          }
+          const conn = await waitForConnection(callbackContext);
           return createCallbackFileSystemHandler({
             connection: conn,
             callbackContext,
@@ -768,18 +837,19 @@ async function handleCreateRuntime(message, connection, state) {
       } else {
         data = cmd.data;
       }
-      const wsCommandMsg = {
-        type: 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: MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: IsolateEvents.WS_COMMAND,
+        payload
+      });
     });
     runtime.fetch.onClientWebSocketCommand((cmd) => {
       const targetConnection = callbackContext.connection;
@@ -793,40 +863,62 @@ async function handleCreateRuntime(message, connection, state) {
         data = cmd.data;
       }
       if (cmd.type === "connect") {
-        const msg = {
-          type: 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: MessageType.CLIENT_WS_SEND,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: MessageType.ISOLATE_EVENT,
           isolateId,
+          event: 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: MessageType.CLIENT_WS_CLOSE,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: MessageType.ISOLATE_EVENT,
           isolateId,
+          event: 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: MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: IsolateEvents.WS_CLIENT_CLOSE,
+          payload
+        });
       }
     });
+    runtime.fetch.onEvent((eventName, payload) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      sendMessage(targetConnection.socket, {
+        type: 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, 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) {
@@ -842,14 +934,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, ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -862,14 +960,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 ? ErrorCode.ISOLATE_TIMEOUT : 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, ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleDispatchRequest(message, connection, state) {
@@ -977,34 +1076,38 @@ async function handleWsClose(message, connection, state) {
     sendError(connection.socket, message.requestId, 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 ClientEvents.WS_CLIENT_OPENED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketOpen(payload.socketId, payload.protocol, payload.extensions);
+      break;
+    }
+    case 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 ClientEvents.WS_CLIENT_CLOSED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketClose(payload.socketId, payload.code, payload.reason, payload.wasClean);
+      break;
+    }
+    case 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);
@@ -1148,9 +1251,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;
@@ -1162,17 +1262,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 = {
@@ -1184,13 +1279,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) {
@@ -1318,9 +1406,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,
@@ -1451,13 +1536,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, 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, ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    const currentConn = instance.callbackContext?.connection ?? connection;
+    sendError(currentConn.socket, message.requestId, ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleResetTestEnv(message, connection, state) {
@@ -1539,4 +1646,4 @@ export {
   handleConnection
 };
 
-//# debugId=C809F161C354C84D64756E2164756E21
+//# debugId=DCB2345D02FBF03C64756E2164756E21