@ricsam/isolate 0.0.1 → 0.1.1

package/dist/cjs/internal/daemon/connection.cjs

@@ -0,0 +1,1952 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/daemon/connection.ts
+var exports_connection = {};
+__export(exports_connection, {
+  handleConnection: () => handleConnection
+});
+module.exports = __toCommonJS(exports_connection);
+var import_node_async_hooks = require("node:async_hooks");
+var import_node_crypto = require("node:crypto");
+var import_protocol = require("../protocol/index.cjs");
+var import_callback_fs_handler = require("./callback-fs-handler.cjs");
+var import_runtime = require("../runtime/index.cjs");
+var import_runtime_pool = require("./runtime-pool.cjs");
+var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
+var NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+var DEFAULT_CALLBACK_TIMEOUT_MS = 120000;
+var FETCH_CALLBACK_TIMEOUT_MS = 35000;
+var requestContextStorage = new import_node_async_hooks.AsyncLocalStorage;
+function createAbortError(reason = "The operation was aborted") {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(reason, "AbortError");
+  }
+  const error = new Error(reason);
+  error.name = "AbortError";
+  return error;
+}
+function sendCallbackAbortMessage(connection, targetRequestId, reason) {
+  const abortMessage = {
+    type: import_protocol.MessageType.CALLBACK_ABORT,
+    requestId: connection.nextRequestId++,
+    targetRequestId,
+    reason
+  };
+  sendMessage(connection.socket, abortMessage);
+}
+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 isRuntimeTimeoutError(error) {
+  return error instanceof Error && /^(Execution|Test) timed out after \d+ms$/i.test(error.message);
+}
+function handleConnection(socket, state) {
+  const connection = {
+    socket,
+    isolates: new Set,
+    pendingRequests: new Map,
+    pendingCallbacks: new Map,
+    nextRequestId: 1,
+    nextCallbackId: 1,
+    nextStreamId: 1,
+    activeStreams: new Map,
+    streamReceivers: new Map,
+    callbackStreamReceivers: new Map,
+    dispatchAbortControllers: new Map,
+    earlyAbortedDispatches: new Set
+  };
+  state.connections.set(socket, connection);
+  const parser = import_protocol.createFrameParser();
+  socket.on("data", (data) => {
+    try {
+      for (const frame of parser.feed(new Uint8Array(data))) {
+        handleMessage(frame.message, connection, state).catch((err) => {
+          console.error("Error handling message:", err);
+        });
+      }
+    } catch (err) {
+      console.error("Error parsing frame:", err);
+      socket.destroy();
+    }
+  });
+  socket.on("close", () => {
+    for (const streamId of Array.from(connection.activeStreams.keys())) {
+      closeActiveDownloadSession(connection, streamId);
+    }
+    for (const [, controller] of connection.dispatchAbortControllers) {
+      controller.abort();
+    }
+    connection.dispatchAbortControllers.clear();
+    connection.earlyAbortedDispatches.clear();
+    for (const isolateId of connection.isolates) {
+      const instance = state.isolates.get(isolateId);
+      if (instance) {
+        if (instance.namespaceId != null && !instance.isDisposed) {
+          if (instance.isPoisoned) {
+            hardDeleteRuntime(instance, state, "owner connection closed after runtime was poisoned").catch(() => {});
+          } else {
+            softDeleteRuntime(instance, state, "owner connection closed; preserving namespaced runtime for reuse");
+          }
+        } else if (!instance.isDisposed) {
+          hardDeleteRuntime(instance, state, "owner connection closed for non-namespaced runtime").catch(() => {});
+        }
+      }
+    }
+    for (const [, pending] of connection.pendingCallbacks) {
+      pending.cleanup?.();
+      pending.reject(new Error("Connection closed"));
+    }
+    connection.pendingCallbacks.clear();
+    state.connections.delete(socket);
+  });
+  socket.on("error", (err) => {
+    console.error("Socket error:", err);
+  });
+}
+function sendMessage(socket, message) {
+  const frame = import_protocol.buildFrame(message);
+  socket.write(frame);
+}
+function closeActiveDownloadSession(connection, streamId) {
+  const session = connection.activeStreams.get(streamId);
+  if (!session) {
+    return;
+  }
+  session.state = "closed";
+  if (session.creditResolver) {
+    session.creditResolver();
+    session.creditResolver = undefined;
+  }
+  if (session.cancelReader) {
+    session.cancelReader();
+    session.cancelReader = undefined;
+  }
+  connection.activeStreams.delete(streamId);
+}
+function sendError(socket, requestId, code, message, details) {
+  const response = {
+    type: import_protocol.MessageType.RESPONSE_ERROR,
+    requestId,
+    code,
+    message,
+    details
+  };
+  sendMessage(socket, response);
+}
+function sendOk(socket, requestId, data) {
+  const response = {
+    type: import_protocol.MessageType.RESPONSE_OK,
+    requestId,
+    data
+  };
+  sendMessage(socket, response);
+}
+async function handleMessage(message, connection, state) {
+  state.stats.totalRequestsProcessed++;
+  switch (message.type) {
+    case import_protocol.MessageType.CREATE_RUNTIME:
+      await handleCreateRuntime(message, connection, state);
+      break;
+    case import_protocol.MessageType.DISPOSE_RUNTIME:
+      await handleDisposeRuntime(message, connection, state);
+      break;
+    case import_protocol.MessageType.EVAL:
+      await handleEval(message, connection, state);
+      break;
+    case import_protocol.MessageType.DISPATCH_REQUEST:
+      await handleDispatchRequest(message, connection, state);
+      break;
+    case import_protocol.MessageType.DISPATCH_REQUEST_ABORT:
+      handleDispatchRequestAbort(message, connection);
+      break;
+    case import_protocol.MessageType.CALLBACK_RESPONSE:
+      handleCallbackResponse(message, connection);
+      break;
+    case import_protocol.MessageType.WS_OPEN:
+      await handleWsOpen(message, connection, state);
+      break;
+    case import_protocol.MessageType.WS_MESSAGE:
+      await handleWsMessage(message, connection, state);
+      break;
+    case import_protocol.MessageType.WS_CLOSE:
+      await handleWsClose(message, connection, state);
+      break;
+    case import_protocol.MessageType.FETCH_GET_UPGRADE_REQUEST:
+      await handleFetchGetUpgradeRequest(message, connection, state);
+      break;
+    case import_protocol.MessageType.FETCH_HAS_SERVE_HANDLER:
+      await handleFetchHasServeHandler(message, connection, state);
+      break;
+    case import_protocol.MessageType.FETCH_HAS_ACTIVE_CONNECTIONS:
+      await handleFetchHasActiveConnections(message, connection, state);
+      break;
+    case import_protocol.MessageType.FETCH_WS_ERROR:
+      await handleFetchWsError(message, connection, state);
+      break;
+    case import_protocol.MessageType.TIMERS_CLEAR_ALL:
+      await handleTimersClearAll(message, connection, state);
+      break;
+    case import_protocol.MessageType.CONSOLE_RESET:
+      await handleConsoleReset(message, connection, state);
+      break;
+    case import_protocol.MessageType.CONSOLE_GET_TIMERS:
+      await handleConsoleGetTimers(message, connection, state);
+      break;
+    case import_protocol.MessageType.CONSOLE_GET_COUNTERS:
+      await handleConsoleGetCounters(message, connection, state);
+      break;
+    case import_protocol.MessageType.CONSOLE_GET_GROUP_DEPTH:
+      await handleConsoleGetGroupDepth(message, connection, state);
+      break;
+    case import_protocol.MessageType.RUN_TESTS:
+      await handleRunTests(message, connection, state);
+      break;
+    case import_protocol.MessageType.RESET_TEST_ENV:
+      await handleResetTestEnv(message, connection, state);
+      break;
+    case import_protocol.MessageType.HAS_TESTS:
+      await handleHasTests(message, connection, state);
+      break;
+    case import_protocol.MessageType.GET_TEST_COUNT:
+      await handleGetTestCount(message, connection, state);
+      break;
+    case import_protocol.MessageType.GET_COLLECTED_DATA:
+      await handleGetCollectedData(message, connection, state);
+      break;
+    case import_protocol.MessageType.CLEAR_COLLECTED_DATA:
+      await handleClearCollectedData(message, connection, state);
+      break;
+    case import_protocol.MessageType.PING:
+      sendMessage(connection.socket, { type: import_protocol.MessageType.PONG });
+      break;
+    case import_protocol.MessageType.STREAM_PUSH:
+      handleStreamPush(message, connection);
+      break;
+    case import_protocol.MessageType.STREAM_PULL:
+      handleStreamPull(message, connection);
+      break;
+    case import_protocol.MessageType.STREAM_CLOSE:
+      handleStreamClose(message, connection);
+      break;
+    case import_protocol.MessageType.STREAM_ERROR:
+      handleStreamError(message, connection);
+      break;
+    case import_protocol.MessageType.CALLBACK_STREAM_START:
+      handleCallbackStreamStart(message, connection);
+      break;
+    case import_protocol.MessageType.CALLBACK_STREAM_CHUNK:
+      handleCallbackStreamChunk(message, connection);
+      break;
+    case import_protocol.MessageType.CALLBACK_STREAM_END:
+      handleCallbackStreamEnd(message, connection);
+      break;
+    case import_protocol.MessageType.CLIENT_EVENT:
+      handleClientEvent(message, connection, state);
+      break;
+    default:
+      sendError(connection.socket, message.requestId ?? 0, import_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
+  }
+}
+function logRuntimeLifecycle(state, event, instance, reason, level = "log") {
+  const logger = level === "warn" ? console.warn : console.log;
+  const poisonedSuffix = instance.isPoisoned ? " poisoned=true" : "";
+  const reasonSuffix = reason ? `: ${reason}` : "";
+  logger(`[isolate-daemon] ${event} runtime ${import_runtime_pool.formatRuntimeLabel(instance)}${poisonedSuffix}${reasonSuffix}; ${import_runtime_pool.formatRuntimePoolSnapshot(import_runtime_pool.collectRuntimePoolSnapshot(state))}`);
+}
+async function hardDeleteRuntime(instance, state, reason) {
+  const wasPooled = instance.isDisposed;
+  try {
+    if (instance.runtimeAbortController && !instance.runtimeAbortController.signal.aborted) {
+      instance.runtimeAbortController.abort(new Error(reason ?? "Runtime was permanently disposed"));
+    }
+    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;
+    }
+    logRuntimeLifecycle(state, wasPooled ? "evicted pooled" : "hard-disposed", instance, reason);
+  }
+}
+var RECONNECTION_TIMEOUT_MS = 30000;
+function softDeleteRuntime(instance, state, reason) {
+  if (instance.runtimeAbortController && !instance.runtimeAbortController.signal.aborted) {
+    instance.runtimeAbortController.abort(new Error(reason ?? "Runtime was soft-disposed"));
+  }
+  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();
+  instance.runtime.console.reset();
+  instance.runtime.pendingCallbacks.length = 0;
+  instance.returnedCallbacks?.clear();
+  instance.returnedPromises?.clear();
+  instance.returnedIterators?.clear();
+  instance.runtime.clearModuleCache();
+  logRuntimeLifecycle(state, "soft-disposed", instance, reason);
+}
+function reuseNamespacedRuntime(instance, connection, message, state) {
+  instance.ownerConnection = connection.socket;
+  instance.isDisposed = false;
+  instance.isPoisoned = false;
+  instance.disposedAt = undefined;
+  instance.lastActivity = Date.now();
+  instance.runtimeAbortController = new AbortController;
+  connection.isolates.add(instance.isolateId);
+  const callbacks = message.options.callbacks;
+  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;
+    instance.callbackContext.testEnvironmentOnEvent = testEnvOptions?.callbacks?.onEvent?.callbackId;
+    instance.callbackContext.playwright = {
+      handlerCallbackId: callbacks?.playwright?.handlerCallbackId,
+      onBrowserConsoleLogCallbackId: callbacks?.playwright?.onBrowserConsoleLogCallbackId,
+      onNetworkRequestCallbackId: callbacks?.playwright?.onNetworkRequestCallbackId,
+      onNetworkResponseCallbackId: callbacks?.playwright?.onNetworkResponseCallbackId
+    };
+    instance.callbackContext.fs = {
+      readFile: callbacks?.fs?.readFile?.callbackId,
+      writeFile: callbacks?.fs?.writeFile?.callbackId,
+      stat: callbacks?.fs?.stat?.callbackId,
+      readdir: callbacks?.fs?.readdir?.callbackId,
+      unlink: callbacks?.fs?.unlink?.callbackId,
+      mkdir: callbacks?.fs?.mkdir?.callbackId,
+      rmdir: callbacks?.fs?.rmdir?.callbackId
+    };
+    instance.callbackContext.custom.clear();
+    if (callbacks?.custom) {
+      for (const [name, reg] of Object.entries(callbacks.custom)) {
+        if (reg) {
+          instance.callbackContext.custom.set(name, reg.callbackId);
+        }
+      }
+    }
+  }
+  instance.callbacks.clear();
+  if (callbacks?.console?.onEntry) {
+    instance.callbacks.set(callbacks.console.onEntry.callbackId, {
+      ...callbacks.console.onEntry,
+      name: "onEntry"
+    });
+  }
+  if (callbacks?.fetch) {
+    instance.callbacks.set(callbacks.fetch.callbackId, callbacks.fetch);
+  }
+  if (callbacks?.fs) {
+    for (const [name, reg] of Object.entries(callbacks.fs)) {
+      if (reg) {
+        instance.callbacks.set(reg.callbackId, { ...reg, name });
+      }
+    }
+  }
+  if (callbacks?.moduleLoader) {
+    instance.callbacks.set(callbacks.moduleLoader.callbackId, callbacks.moduleLoader);
+  }
+  if (callbacks?.custom) {
+    for (const [name, reg] of Object.entries(callbacks.custom)) {
+      if (reg) {
+        instance.callbacks.set(reg.callbackId, { ...reg, name });
+      }
+    }
+  }
+  if (testEnvOptions?.callbacks?.onEvent) {
+    instance.callbacks.set(testEnvOptions.callbacks.onEvent.callbackId, {
+      ...testEnvOptions.callbacks.onEvent,
+      name: "testEnvironment.onEvent"
+    });
+  }
+  if (callbacks?.playwright) {
+    instance.callbacks.set(callbacks.playwright.handlerCallbackId, {
+      callbackId: callbacks.playwright.handlerCallbackId,
+      name: "playwright.handler",
+      type: "async"
+    });
+    if (callbacks.playwright.onBrowserConsoleLogCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onBrowserConsoleLogCallbackId, {
+        callbackId: callbacks.playwright.onBrowserConsoleLogCallbackId,
+        name: "playwright.onBrowserConsoleLog",
+        type: "sync"
+      });
+    }
+    if (callbacks.playwright.onNetworkRequestCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onNetworkRequestCallbackId, {
+        callbackId: callbacks.playwright.onNetworkRequestCallbackId,
+        name: "playwright.onNetworkRequest",
+        type: "sync"
+      });
+    }
+    if (callbacks.playwright.onNetworkResponseCallbackId !== undefined) {
+      instance.callbacks.set(callbacks.playwright.onNetworkResponseCallbackId, {
+        callbackId: callbacks.playwright.onNetworkResponseCallbackId,
+        name: "playwright.onNetworkResponse",
+        type: "sync"
+      });
+    }
+  }
+  instance.returnedCallbacks = new Map;
+  instance.returnedPromises = new Map;
+  instance.returnedIterators = new Map;
+  instance.nextLocalCallbackId = 1e6;
+  logRuntimeLifecycle(state, "reused pooled", instance);
+}
+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");
+}
+function getCurrentHostSignal(instance) {
+  return requestContextStorage.getStore()?.signal ?? instance?.runtimeAbortController?.signal;
+}
+async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback, options) {
+  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, options);
+  } 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, options);
+    }
+    throw err;
+  }
+}
+async function evictOldestDisposedRuntime(state) {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [, instance] of state.isolates) {
+    if (instance.isDisposed && instance.disposedAt !== undefined) {
+      if (instance.disposedAt < oldestTime) {
+        oldestTime = instance.disposedAt;
+        oldest = instance;
+      }
+    }
+  }
+  if (oldest) {
+    try {
+      await hardDeleteRuntime(oldest, state, "LRU eviction to make room for a new runtime");
+    } catch {}
+    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) {
+      if (!existing.isDisposed) {
+        if (existing.ownerConnection === connection.socket) {
+          sendOk(connection.socket, message.requestId, {
+            isolateId: existing.isolateId,
+            reused: true
+          });
+          return;
+        }
+        sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, `Namespace "${namespaceId}" already has an active runtime`);
+        return;
+      }
+      reuseNamespacedRuntime(existing, connection, message, state);
+      sendOk(connection.socket, message.requestId, {
+        isolateId: existing.isolateId,
+        reused: true
+      });
+      return;
+    }
+    if (state.namespacedCreatesInFlight.has(namespaceId)) {
+      sendError(connection.socket, message.requestId, import_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)) {
+        const targetLabel = namespaceId != null ? `namespace=${JSON.stringify(namespaceId)}` : "non-namespaced";
+        console.warn(`[isolate-daemon] denied runtime create for ${targetLabel}: ${import_runtime_pool.formatRuntimePoolSnapshot(import_runtime_pool.collectRuntimePoolSnapshot(state))}`);
+        sendError(connection.socket, message.requestId, import_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;
+    const fsCallbacks = message.options.callbacks?.fs;
+    const moduleLoaderCallback = message.options.callbacks?.moduleLoader;
+    const customCallbacks = message.options.callbacks?.custom;
+    const callbackContext = {
+      connection,
+      consoleOnEntry: consoleCallbacks?.onEntry?.callbackId,
+      fetch: fetchCallback?.callbackId,
+      moduleLoader: moduleLoaderCallback?.callbackId,
+      testEnvironmentOnEvent: message.options.testEnvironment != null && typeof message.options.testEnvironment === "object" ? message.options.testEnvironment.callbacks?.onEvent?.callbackId : undefined,
+      playwright: {
+        handlerCallbackId: message.options.callbacks?.playwright?.handlerCallbackId,
+        onBrowserConsoleLogCallbackId: message.options.callbacks?.playwright?.onBrowserConsoleLogCallbackId,
+        onNetworkRequestCallbackId: message.options.callbacks?.playwright?.onNetworkRequestCallbackId,
+        onNetworkResponseCallbackId: message.options.callbacks?.playwright?.onNetworkResponseCallbackId
+      },
+      fs: {
+        readFile: fsCallbacks?.readFile?.callbackId,
+        writeFile: fsCallbacks?.writeFile?.callbackId,
+        stat: fsCallbacks?.stat?.callbackId,
+        readdir: fsCallbacks?.readdir?.callbackId,
+        unlink: fsCallbacks?.unlink?.callbackId,
+        mkdir: fsCallbacks?.mkdir?.callbackId,
+        rmdir: fsCallbacks?.rmdir?.callbackId
+      },
+      custom: new Map(customCallbacks ? Object.entries(customCallbacks).map(([name, reg]) => [name, reg.callbackId]) : [])
+    };
+    const instance = {
+      isolateId,
+      runtime: null,
+      ownerConnection: connection.socket,
+      callbacks: new Map,
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+      runtimeAbortController: new AbortController,
+      returnedCallbacks: new Map,
+      returnedPromises: new Map,
+      returnedIterators: new Map,
+      nextLocalCallbackId: 1e6,
+      namespaceId,
+      isDisposed: false,
+      isPoisoned: false,
+      callbackContext
+    };
+    let bridgedCustomFunctions;
+    let customFnMarshalOptions;
+    if (customCallbacks) {
+      const createMarshalContext = () => ({
+        registerCallback: (fn) => {
+          const callbackId = instance.nextLocalCallbackId++;
+          instance.returnedCallbacks.set(callbackId, fn);
+          return callbackId;
+        },
+        registerPromise: (promise) => {
+          const promiseId = instance.nextLocalCallbackId++;
+          instance.returnedPromises.set(promiseId, promise);
+          return promiseId;
+        },
+        registerIterator: (iterator) => {
+          const iteratorId = instance.nextLocalCallbackId++;
+          instance.returnedIterators.set(iteratorId, iterator);
+          return iteratorId;
+        }
+      });
+      const addCallbackIdsToRefs = (value) => {
+        if (value === null || typeof value !== "object")
+          return value;
+        if (import_protocol.isPromiseRef(value)) {
+          if ("__resolveCallbackId" in value)
+            return value;
+          const resolveCallbackId = instance.nextLocalCallbackId++;
+          instance.returnedCallbacks.set(resolveCallbackId, async (promiseId) => {
+            const promise = instance.returnedPromises.get(promiseId);
+            if (!promise)
+              throw new Error(`Promise ${promiseId} not found`);
+            const result2 = await promise;
+            instance.returnedPromises.delete(promiseId);
+            const ctx = createMarshalContext();
+            const marshalled = await import_protocol.marshalValue(result2, ctx);
+            return addCallbackIdsToRefs(marshalled);
+          });
+          return { ...value, __resolveCallbackId: resolveCallbackId };
+        }
+        if (import_protocol.isAsyncIteratorRef(value)) {
+          if ("__nextCallbackId" in value)
+            return value;
+          const nextCallbackId = instance.nextLocalCallbackId++;
+          instance.returnedCallbacks.set(nextCallbackId, async (iteratorId) => {
+            const iterator = instance.returnedIterators.get(iteratorId);
+            if (!iterator)
+              throw new Error(`Iterator ${iteratorId} not found`);
+            const result2 = await iterator.next();
+            if (result2.done)
+              instance.returnedIterators.delete(iteratorId);
+            const ctx = createMarshalContext();
+            const marshalledValue = await import_protocol.marshalValue(result2.value, ctx);
+            return { done: result2.done, value: addCallbackIdsToRefs(marshalledValue) };
+          });
+          const returnCallbackId = instance.nextLocalCallbackId++;
+          instance.returnedCallbacks.set(returnCallbackId, async (iteratorId, returnValue) => {
+            const iterator = instance.returnedIterators.get(iteratorId);
+            instance.returnedIterators.delete(iteratorId);
+            if (!iterator || !iterator.return)
+              return { done: true, value: undefined };
+            const result2 = await iterator.return(returnValue);
+            const ctx = createMarshalContext();
+            const marshalledValue = await import_protocol.marshalValue(result2.value, ctx);
+            return { done: true, value: addCallbackIdsToRefs(marshalledValue) };
+          });
+          const throwCallbackId = instance.nextLocalCallbackId++;
+          instance.returnedCallbacks.set(throwCallbackId, async (iteratorId, errorValue) => {
+            const iterator = instance.returnedIterators.get(iteratorId);
+            if (!iterator) {
+              throw new Error(`Iterator ${iteratorId} not found`);
+            }
+            try {
+              if (!iterator.throw) {
+                throw Object.assign(new Error(errorValue?.message ?? "Iterator does not support throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+              }
+              const thrownError = Object.assign(new Error(errorValue?.message ?? "Iterator throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+              const result2 = await iterator.throw(thrownError);
+              if (result2.done) {
+                instance.returnedIterators.delete(iteratorId);
+              }
+              const ctx = createMarshalContext();
+              const marshalledValue = await import_protocol.marshalValue(result2.value, ctx);
+              return { done: result2.done, value: addCallbackIdsToRefs(marshalledValue) };
+            } catch (error) {
+              instance.returnedIterators.delete(iteratorId);
+              throw error;
+            }
+          });
+          return {
+            ...value,
+            __nextCallbackId: nextCallbackId,
+            __returnCallbackId: returnCallbackId,
+            __throwCallbackId: throwCallbackId
+          };
+        }
+        if (Array.isArray(value))
+          return value.map((item) => addCallbackIdsToRefs(item));
+        const result = {};
+        for (const key of Object.keys(value)) {
+          result[key] = addCallbackIdsToRefs(value[key]);
+        }
+        return result;
+      };
+      const LOCAL_CALLBACK_THRESHOLD = 1e6;
+      const invokeCallback = async (callbackId, args) => {
+        if (callbackId >= LOCAL_CALLBACK_THRESHOLD) {
+          const callback = instance.returnedCallbacks.get(callbackId);
+          if (!callback) {
+            throw new Error(`Local callback ${callbackId} not found`);
+          }
+          return await callback(...args);
+        } else {
+          const conn = await waitForConnection(callbackContext);
+          try {
+            return await invokeClientCallback(conn, callbackId, args, {
+              signal: getCurrentHostSignal(instance)
+            });
+          } catch (err) {
+            if (callbackContext.reconnectionPromise && !callbackContext.connection) {
+              const newConn = await callbackContext.reconnectionPromise.promise;
+              return invokeClientCallback(newConn, callbackId, args, {
+                signal: getCurrentHostSignal(instance)
+              });
+            }
+            throw err;
+          }
+        }
+      };
+      customFnMarshalOptions = { createMarshalContext, addCallbackIdsToRefs, invokeCallback };
+      bridgedCustomFunctions = {};
+      for (const [name, registration] of Object.entries(customCallbacks)) {
+        if (name.includes(":"))
+          continue;
+        const callbackContext_ = callbackContext;
+        if (registration.type === "asyncIterator") {
+          bridgedCustomFunctions[name] = {
+            type: "asyncIterator",
+            fn: (...args) => {
+              const startCallbackId = callbackContext_.custom.get(`${name}:start`);
+              const nextCallbackId = callbackContext_.custom.get(`${name}:next`);
+              const returnCallbackId = callbackContext_.custom.get(`${name}:return`);
+              async function* bridgedIterator() {
+                const startResult = await invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(`${name}:start`), args, `AsyncIterator '${name}' start`, invokeClientCallback, { signal: getCurrentHostSignal(instance) });
+                const iteratorId = startResult.iteratorId;
+                try {
+                  while (true) {
+                    const nextResult = await invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(`${name}:next`), [iteratorId], `AsyncIterator '${name}' next`, invokeClientCallback, { signal: getCurrentHostSignal(instance) });
+                    if (nextResult.done)
+                      return nextResult.value;
+                    yield nextResult.value;
+                  }
+                } finally {
+                  const retConn = callbackContext_.connection;
+                  const retCbId = callbackContext_.custom.get(`${name}:return`);
+                  if (retConn && retCbId !== undefined) {
+                    await invokeClientCallback(retConn, retCbId, [iteratorId], {
+                      signal: getCurrentHostSignal(instance)
+                    }).catch(() => {});
+                  }
+                }
+              }
+              return bridgedIterator();
+            }
+          };
+        } else {
+          bridgedCustomFunctions[name] = {
+            type: registration.type,
+            fn: async (...args) => {
+              return invokeCallbackWithReconnect(callbackContext_, () => callbackContext_.custom.get(name), args, `Custom function '${name}'`, invokeClientCallback, { signal: getCurrentHostSignal(instance) });
+            }
+          };
+        }
+      }
+    }
+    let moduleLoader;
+    if (moduleLoaderCallback) {
+      moduleLoader = async (specifier, importer) => {
+        return invokeCallbackWithReconnect(callbackContext, () => callbackContext.moduleLoader, [specifier, importer], "Module loader", invokeClientCallback, { signal: getCurrentHostSignal(instance) });
+      };
+    }
+    let testEnvironment;
+    if (message.options.testEnvironment) {
+      const testEnvOption = message.options.testEnvironment;
+      const testEnvOptions = typeof testEnvOption === "object" ? testEnvOption : undefined;
+      testEnvironment = {
+        onEvent: testEnvOptions?.callbacks?.onEvent ? (event) => {
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.testEnvironmentOnEvent;
+          if (!conn || callbackId === undefined) {
+            return;
+          }
+          const promise = invokeClientCallback(conn, callbackId, [JSON.stringify(event)], { signal: getCurrentHostSignal(instance) }).catch(() => {});
+          instance.runtime?.pendingCallbacks?.push(promise);
+        } : undefined,
+        testTimeout: testEnvOptions?.testTimeout
+      };
+      if (testEnvOptions?.callbacks?.onEvent) {
+        instance.callbacks.set(testEnvOptions.callbacks.onEvent.callbackId, {
+          ...testEnvOptions.callbacks.onEvent,
+          name: "testEnvironment.onEvent"
+        });
+      }
+    }
+    let playwrightOptions;
+    const playwrightCallbacks = message.options.callbacks?.playwright;
+    if (playwrightCallbacks) {
+      playwrightOptions = {
+        handler: async (op) => {
+          try {
+            const resultJson = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.playwright.handlerCallbackId, [JSON.stringify(op)], "Playwright handler", invokeClientCallback, { signal: getCurrentHostSignal(instance) });
+            return JSON.parse(resultJson);
+          } catch (err) {
+            const error = err;
+            return { ok: false, error: { name: error.name, message: error.message } };
+          }
+        },
+        timeout: message.options.playwright?.timeout,
+        console: playwrightCallbacks.console,
+        onEvent: (event) => {
+          const conn = callbackContext.connection;
+          if (!conn) {
+            return;
+          }
+          if (event.type === "browserConsoleLog" && callbackContext.playwright.onBrowserConsoleLogCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onBrowserConsoleLogCallbackId, [{ level: event.level, stdout: event.stdout, timestamp: event.timestamp }], { signal: getCurrentHostSignal(instance) }).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          } else if (event.type === "networkRequest" && callbackContext.playwright.onNetworkRequestCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onNetworkRequestCallbackId, [event], { signal: getCurrentHostSignal(instance) }).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          } else if (event.type === "networkResponse" && callbackContext.playwright.onNetworkResponseCallbackId !== undefined) {
+            const promise = invokeClientCallback(conn, callbackContext.playwright.onNetworkResponseCallbackId, [event], { signal: getCurrentHostSignal(instance) }).catch(() => {});
+            instance.runtime?.pendingCallbacks?.push(promise);
+          }
+        }
+      };
+    }
+    const runtime = await import_runtime.createRuntime({
+      memoryLimitMB: message.options.memoryLimitMB ?? state.options.defaultMemoryLimitMB,
+      executionTimeout: message.options.executionTimeout,
+      cwd: message.options.cwd,
+      console: {
+        onEntry: (entry) => {
+          const conn = callbackContext.connection;
+          const callbackId = callbackContext.consoleOnEntry;
+          if (!conn || callbackId === undefined)
+            return;
+          const promise = invokeClientCallback(conn, callbackId, [entry]).catch(() => {});
+          runtime.pendingCallbacks.push(promise);
+        }
+      },
+      fetch: async (url, init) => {
+        if (init.signal.aborted) {
+          throw createAbortError();
+        }
+        const serialized = {
+          url,
+          method: init.method,
+          headers: init.headers,
+          body: init.rawBody,
+          signalAborted: init.signal.aborted
+        };
+        const callbackAbortController = new AbortController;
+        const onInitAbort = () => callbackAbortController.abort();
+        const currentSignal = getCurrentHostSignal(instance);
+        const onCurrentAbort = () => callbackAbortController.abort();
+        init.signal.addEventListener("abort", onInitAbort, { once: true });
+        currentSignal?.addEventListener("abort", onCurrentAbort, { once: true });
+        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback, {
+          signal: callbackAbortController.signal,
+          timeoutMs: FETCH_CALLBACK_TIMEOUT_MS,
+          timeoutLabel: "fetch callback"
+        }).finally(() => {
+          init.signal.removeEventListener("abort", onInitAbort);
+          currentSignal?.removeEventListener("abort", onCurrentAbort);
+        });
+        if (result && typeof result === "object" && result.__streamingResponse) {
+          const response = result.response;
+          response.__isCallbackStream = true;
+          return response;
+        }
+        return import_protocol.deserializeResponse(result);
+      },
+      fs: {
+        getDirectory: async (dirPath) => {
+          const conn = await waitForConnection(callbackContext);
+          return import_callback_fs_handler.createCallbackFileSystemHandler({
+            connection: conn,
+            callbackContext,
+            invokeClientCallback,
+            basePath: dirPath,
+            getSignal: () => getCurrentHostSignal(instance)
+          });
+        }
+      },
+      moduleLoader,
+      customFunctions: bridgedCustomFunctions,
+      customFunctionsMarshalOptions: customFnMarshalOptions,
+      testEnvironment,
+      playwright: playwrightOptions
+    });
+    instance.runtime = runtime;
+    if (consoleCallbacks?.onEntry) {
+      instance.callbacks.set(consoleCallbacks.onEntry.callbackId, {
+        ...consoleCallbacks.onEntry,
+        name: "onEntry"
+      });
+    }
+    if (fetchCallback) {
+      instance.callbacks.set(fetchCallback.callbackId, fetchCallback);
+    }
+    if (fsCallbacks) {
+      for (const [name, reg] of Object.entries(fsCallbacks)) {
+        if (reg) {
+          instance.callbacks.set(reg.callbackId, { ...reg, name });
+        }
+      }
+    }
+    if (moduleLoaderCallback) {
+      instance.callbacks.set(moduleLoaderCallback.callbackId, moduleLoaderCallback);
+    }
+    if (customCallbacks) {
+      for (const [name, reg] of Object.entries(customCallbacks)) {
+        if (reg) {
+          instance.callbacks.set(reg.callbackId, { ...reg, name });
+        }
+      }
+    }
+    if (playwrightCallbacks) {
+      instance.callbacks.set(playwrightCallbacks.handlerCallbackId, {
+        callbackId: playwrightCallbacks.handlerCallbackId,
+        name: "playwright.handler",
+        type: "async"
+      });
+      if (playwrightCallbacks.onBrowserConsoleLogCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onBrowserConsoleLogCallbackId, {
+          callbackId: playwrightCallbacks.onBrowserConsoleLogCallbackId,
+          name: "playwright.onBrowserConsoleLog",
+          type: "sync"
+        });
+      }
+      if (playwrightCallbacks.onNetworkRequestCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onNetworkRequestCallbackId, {
+          callbackId: playwrightCallbacks.onNetworkRequestCallbackId,
+          name: "playwright.onNetworkRequest",
+          type: "sync"
+        });
+      }
+      if (playwrightCallbacks.onNetworkResponseCallbackId !== undefined) {
+        instance.callbacks.set(playwrightCallbacks.onNetworkResponseCallbackId, {
+          callbackId: playwrightCallbacks.onNetworkResponseCallbackId,
+          name: "playwright.onNetworkResponse",
+          type: "sync"
+        });
+      }
+    }
+    state.isolates.set(isolateId, instance);
+    connection.isolates.add(isolateId);
+    state.stats.totalIsolatesCreated++;
+    if (namespaceId != null) {
+      state.namespacedRuntimes.set(namespaceId, instance);
+    }
+    runtime.fetch.onWebSocketCommand((cmd) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      let data;
+      if (cmd.data instanceof ArrayBuffer) {
+        data = new Uint8Array(cmd.data);
+      } else {
+        data = cmd.data;
+      }
+      const payload = {
+        type: cmd.type,
+        connectionId: cmd.connectionId,
+        data,
+        code: cmd.code,
+        reason: cmd.reason
+      };
+      sendMessage(targetConnection.socket, {
+        type: import_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: import_protocol.IsolateEvents.WS_COMMAND,
+        payload
+      });
+    });
+    runtime.fetch.onClientWebSocketCommand((cmd) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      let data;
+      if (cmd.data instanceof ArrayBuffer) {
+        data = new Uint8Array(cmd.data);
+      } else {
+        data = cmd.data;
+      }
+      if (cmd.type === "connect") {
+        const payload = {
+          socketId: cmd.socketId,
+          url: cmd.url,
+          protocols: cmd.protocols
+        };
+        sendMessage(targetConnection.socket, {
+          type: import_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_protocol.IsolateEvents.WS_CLIENT_CONNECT,
+          payload
+        });
+      } else if (cmd.type === "send") {
+        const payload = {
+          socketId: cmd.socketId,
+          data
+        };
+        sendMessage(targetConnection.socket, {
+          type: import_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_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, {
+          type: import_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_protocol.IsolateEvents.WS_CLIENT_CLOSE,
+          payload
+        });
+      }
+    });
+    runtime.fetch.onEvent((eventName, payload) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      sendMessage(targetConnection.socket, {
+        type: import_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: eventName,
+        payload
+      });
+    });
+    sendOk(connection.socket, message.requestId, { isolateId, reused: false });
+    logRuntimeLifecycle(state, "created", instance);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_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) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  if (instance.ownerConnection !== connection.socket) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not owned by this connection`);
+    return;
+  }
+  try {
+    connection.isolates.delete(message.isolateId);
+    const requestReason = typeof message.reason === "string" && message.reason.length > 0 ? message.reason : message.hard ? "client requested hard dispose" : undefined;
+    if (instance.namespaceId != null) {
+      if (message.hard || instance.isPoisoned) {
+        await hardDeleteRuntime(instance, state, requestReason);
+      } else {
+        softDeleteRuntime(instance, state, requestReason);
+      }
+    } else {
+      await hardDeleteRuntime(instance, state, requestReason);
+    }
+    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_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleEval(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    await instance.runtime.eval(message.code, {
+      filename: message.filename,
+      executionTimeout: message.executionTimeout
+    });
+    sendOk(connection.socket, message.requestId, { value: undefined });
+  } catch (err) {
+    const error = err;
+    if (isRuntimeTimeoutError(error)) {
+      instance.isPoisoned = true;
+    } else if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleDispatchRequest(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  const dispatchAbortController = new AbortController;
+  connection.dispatchAbortControllers.set(message.requestId, dispatchAbortController);
+  if (connection.earlyAbortedDispatches.has(message.requestId) || message.request.signalAborted) {
+    dispatchAbortController.abort();
+    connection.earlyAbortedDispatches.delete(message.requestId);
+  }
+  await requestContextStorage.run({
+    ...message.context ?? {},
+    signal: dispatchAbortController.signal
+  }, async () => {
+    try {
+      let requestBody = null;
+      if (message.request.bodyStreamId !== undefined) {
+        requestBody = await receiveStreamedBody(connection, message.request.bodyStreamId);
+      } else if (message.request.body) {
+        requestBody = message.request.body;
+      }
+      const request = new Request(message.request.url, {
+        method: message.request.method,
+        headers: message.request.headers,
+        body: requestBody,
+        signal: dispatchAbortController.signal
+      });
+      const response = await instance.runtime.fetch.dispatchRequest(request, {
+        signal: dispatchAbortController.signal
+      });
+      if (response.body) {
+        await sendStreamedResponse(connection, message.requestId, response);
+      } else {
+        const headers = [];
+        response.headers.forEach((value, key) => {
+          headers.push([key, value]);
+        });
+        sendOk(connection.socket, message.requestId, {
+          response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            body: null
+          }
+        });
+      }
+    } catch (err) {
+      const error = err;
+      sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+    } finally {
+      connection.dispatchAbortControllers.delete(message.requestId);
+      connection.earlyAbortedDispatches.delete(message.requestId);
+    }
+  });
+}
+function handleDispatchRequestAbort(message, connection) {
+  const controller = connection.dispatchAbortControllers.get(message.targetRequestId);
+  if (controller) {
+    controller.abort();
+    return;
+  }
+  connection.earlyAbortedDispatches.add(message.targetRequestId);
+}
+function receiveStreamedBody(connection, streamId) {
+  return new Promise((resolve, reject) => {
+    const receiver = {
+      streamId,
+      requestId: 0,
+      chunks: [],
+      totalBytes: 0,
+      resolve,
+      reject
+    };
+    connection.streamReceivers.set(streamId, receiver);
+    sendMessage(connection.socket, {
+      type: import_protocol.MessageType.STREAM_PULL,
+      streamId,
+      maxBytes: import_protocol.STREAM_DEFAULT_CREDIT
+    });
+  });
+}
+async function handleWsOpen(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketOpen(message.connectionId);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleWsMessage(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const data = message.data instanceof Uint8Array ? message.data.buffer.slice(message.data.byteOffset, message.data.byteOffset + message.data.byteLength) : message.data;
+    instance.runtime.fetch.dispatchWebSocketMessage(message.connectionId, data);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleWsClose(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketClose(message.connectionId, message.code, message.reason);
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+function handleClientEvent(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance)
+    return;
+  instance.lastActivity = Date.now();
+  switch (message.event) {
+    case import_protocol.ClientEvents.WS_CLIENT_OPENED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketOpen(payload.socketId, payload.protocol, payload.extensions);
+      break;
+    }
+    case import_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_protocol.ClientEvents.WS_CLIENT_CLOSED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketClose(payload.socketId, payload.code, payload.reason, payload.wasClean);
+      break;
+    }
+    case import_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);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const upgradeRequest = instance.runtime.fetch.getUpgradeRequest();
+    sendOk(connection.socket, message.requestId, upgradeRequest);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchHasServeHandler(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const hasHandler = instance.runtime.fetch.hasServeHandler();
+    sendOk(connection.socket, message.requestId, hasHandler);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchHasActiveConnections(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const hasConnections = instance.runtime.fetch.hasActiveConnections();
+    sendOk(connection.socket, message.requestId, hasConnections);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleFetchWsError(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.fetch.dispatchWebSocketError(message.connectionId, new Error(message.error));
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleTimersClearAll(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.timers.clearAll();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleReset(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.console.reset();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetTimers(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const timers = instance.runtime.console.getTimers();
+    sendOk(connection.socket, message.requestId, Object.fromEntries(timers));
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetCounters(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const counters = instance.runtime.console.getCounters();
+    sendOk(connection.socket, message.requestId, Object.fromEntries(counters));
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleConsoleGetGroupDepth(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const depth = instance.runtime.console.getGroupDepth();
+    sendOk(connection.socket, message.requestId, depth);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+function handleCallbackResponse(message, connection) {
+  const pending = connection.pendingCallbacks.get(message.requestId);
+  if (!pending) {
+    console.warn(`No pending callback for requestId: ${message.requestId}`);
+    return;
+  }
+  connection.pendingCallbacks.delete(message.requestId);
+  pending.cleanup?.();
+  if (message.error) {
+    const error = new Error(message.error.message);
+    error.name = message.error.name;
+    if (message.error.stack) {
+      error.stack = message.error.stack;
+    }
+    pending.reject(error);
+  } else {
+    pending.resolve(message.result);
+  }
+}
+async function invokeClientCallback(connection, callbackId, args, options) {
+  const requestId = connection.nextCallbackId++;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_CALLBACK_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId;
+    let onAbort;
+    let callbackInvokeSent = false;
+    const settle = (handler, value) => {
+      if (settled)
+        return;
+      settled = true;
+      connection.pendingCallbacks.delete(requestId);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+      if (options?.signal && onAbort) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+      handler(value);
+    };
+    onAbort = () => {
+      if (settled)
+        return;
+      if (callbackInvokeSent) {
+        sendCallbackAbortMessage(connection, requestId, options?.timeoutLabel ? `${options.timeoutLabel} aborted` : "Callback aborted");
+      }
+      settle(reject, createAbortError());
+    };
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        if (settled)
+          return;
+        const label = options?.timeoutLabel ?? "callback";
+        const timeoutError = new Error(`${label} timed out after ${timeoutMs}ms`);
+        if (callbackInvokeSent) {
+          sendCallbackAbortMessage(connection, requestId, timeoutError.message);
+        }
+        settle(reject, timeoutError);
+      }, timeoutMs);
+    }
+    const pending = {
+      callbackId,
+      cleanup: () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = undefined;
+        }
+        if (options?.signal && onAbort) {
+          options.signal.removeEventListener("abort", onAbort);
+        }
+      },
+      resolve: (result) => settle(resolve, result),
+      reject: (error) => settle(reject, error)
+    };
+    connection.pendingCallbacks.set(requestId, pending);
+    const requestContext = requestContextStorage.getStore();
+    const invoke = {
+      type: import_protocol.MessageType.CALLBACK_INVOKE,
+      requestId,
+      callbackId,
+      args,
+      context: requestContext ? {
+        requestId: requestContext.requestId,
+        metadata: requestContext.metadata
+      } : undefined
+    };
+    sendMessage(connection.socket, invoke);
+    callbackInvokeSent = true;
+  });
+}
+function handleStreamPush(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (!receiver) {
+    sendMessage(connection.socket, {
+      type: import_protocol.MessageType.STREAM_ERROR,
+      streamId: message.streamId,
+      error: "Stream not found"
+    });
+    return;
+  }
+  receiver.chunks.push(message.chunk);
+  receiver.totalBytes += message.chunk.length;
+  sendMessage(connection.socket, {
+    type: import_protocol.MessageType.STREAM_PULL,
+    streamId: message.streamId,
+    maxBytes: import_protocol.STREAM_DEFAULT_CREDIT
+  });
+}
+function handleStreamPull(message, connection) {
+  const session = connection.activeStreams.get(message.streamId);
+  if (!session) {
+    return;
+  }
+  session.credit += message.maxBytes;
+  if (session.creditResolver) {
+    session.creditResolver();
+    session.creditResolver = undefined;
+  }
+}
+function handleStreamClose(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (!receiver) {
+    return;
+  }
+  const totalLength = receiver.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of receiver.chunks) {
+    body.set(chunk, offset);
+    offset += chunk.length;
+  }
+  receiver.resolve(body);
+  connection.streamReceivers.delete(message.streamId);
+}
+function handleStreamError(message, connection) {
+  const receiver = connection.streamReceivers.get(message.streamId);
+  if (receiver) {
+    receiver.reject(new Error(message.error));
+    connection.streamReceivers.delete(message.streamId);
+  }
+  const session = connection.activeStreams.get(message.streamId);
+  if (session) {
+    closeActiveDownloadSession(connection, message.streamId);
+  }
+  const callbackReceiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (callbackReceiver && callbackReceiver.state === "active") {
+    callbackReceiver.state = "errored";
+    callbackReceiver.error = new Error(message.error);
+    const resolvers = callbackReceiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
+}
+function handleCallbackStreamStart(message, connection) {
+  const receiver = {
+    streamId: message.streamId,
+    requestId: message.requestId,
+    metadata: message.metadata,
+    controller: null,
+    state: "active",
+    pendingChunks: [],
+    pullResolvers: [],
+    controllerFinalized: false
+  };
+  const readableStream = new ReadableStream({
+    start(controller) {
+      receiver.controller = controller;
+    },
+    pull(_controller) {
+      if (receiver.controllerFinalized) {
+        return;
+      }
+      if (receiver.pendingChunks.length > 0) {
+        const chunk = receiver.pendingChunks.shift();
+        receiver.controller.enqueue(chunk);
+        return Promise.resolve();
+      }
+      if (receiver.state === "closed") {
+        if (!receiver.controllerFinalized) {
+          receiver.controllerFinalized = true;
+          receiver.controller.close();
+        }
+        return Promise.resolve();
+      }
+      if (receiver.state === "errored") {
+        if (!receiver.controllerFinalized && receiver.error) {
+          receiver.controllerFinalized = true;
+          receiver.controller.error(receiver.error);
+        }
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        receiver.pullResolvers.push(resolve);
+      });
+    },
+    cancel(_reason) {
+      receiver.state = "closed";
+      receiver.controllerFinalized = true;
+      const resolvers = receiver.pullResolvers.splice(0);
+      for (const resolver of resolvers) {
+        resolver();
+      }
+      connection.callbackStreamReceivers.delete(message.streamId);
+      sendMessage(connection.socket, {
+        type: import_protocol.MessageType.CALLBACK_STREAM_CANCEL,
+        streamId: message.streamId
+      });
+      return Promise.resolve();
+    }
+  });
+  const cancelStream = () => {
+    connection.callbackStreamReceivers.delete(message.streamId);
+    sendMessage(connection.socket, {
+      type: import_protocol.MessageType.CALLBACK_STREAM_CANCEL,
+      streamId: message.streamId
+    });
+  };
+  connection.callbackStreamReceivers.set(message.streamId, receiver);
+  const pending = connection.pendingCallbacks.get(message.requestId);
+  if (!pending) {
+    cancelStream();
+    return;
+  }
+  try {
+    const body = NULL_BODY_STATUSES.has(message.metadata.status) ? null : readableStream;
+    const response = new Response(body, {
+      status: message.metadata.status,
+      statusText: message.metadata.statusText,
+      headers: message.metadata.headers
+    });
+    connection.pendingCallbacks.delete(message.requestId);
+    pending.resolve({ __streamingResponse: true, response });
+    if (body === null) {
+      cancelStream();
+    }
+  } catch (err) {
+    connection.pendingCallbacks.delete(message.requestId);
+    cancelStream();
+    const error = err instanceof Error ? err : new Error(String(err));
+    pending.reject(error);
+  }
+}
+function handleCallbackStreamChunk(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver && receiver.state === "active") {
+    if (receiver.pullResolvers.length > 0) {
+      receiver.controller.enqueue(message.chunk);
+      const resolver = receiver.pullResolvers.shift();
+      resolver();
+    } else {
+      receiver.pendingChunks.push(message.chunk);
+    }
+  }
+}
+function handleCallbackStreamEnd(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver) {
+    receiver.state = "closed";
+    while (receiver.pendingChunks.length > 0) {
+      const chunk = receiver.pendingChunks.shift();
+      receiver.controller.enqueue(chunk);
+    }
+    if (!receiver.controllerFinalized) {
+      receiver.controllerFinalized = true;
+      receiver.controller.close();
+    }
+    const resolvers = receiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
+}
+function waitForCredit(session) {
+  return new Promise((resolve) => {
+    session.creditResolver = resolve;
+  });
+}
+async function sendStreamedResponse(connection, requestId, response) {
+  const SEND_LOOP_YIELD_BYTES = 64 * 1024;
+  const streamId = connection.nextStreamId++;
+  const headers = [];
+  response.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  const startMsg = {
+    type: import_protocol.MessageType.RESPONSE_STREAM_START,
+    requestId,
+    streamId,
+    metadata: {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    }
+  };
+  sendMessage(connection.socket, startMsg);
+  if (!response.body) {
+    const endMsg = {
+      type: import_protocol.MessageType.RESPONSE_STREAM_END,
+      requestId,
+      streamId
+    };
+    sendMessage(connection.socket, endMsg);
+    return;
+  }
+  const session = {
+    streamId,
+    direction: "download",
+    requestId,
+    state: "active",
+    bytesTransferred: 0,
+    credit: import_protocol.STREAM_DEFAULT_CREDIT
+  };
+  connection.activeStreams.set(streamId, session);
+  const reader = response.body.getReader();
+  session.cancelReader = () => {
+    reader.cancel("Stream cancelled by client").catch(() => {});
+  };
+  let cancelledByClient = false;
+  let bytesSinceYield = 0;
+  let chunksSinceYield = 0;
+  try {
+    streamLoop:
+      while (true) {
+        while (session.credit < import_protocol.STREAM_CHUNK_SIZE && session.state === "active") {
+          await waitForCredit(session);
+        }
+        if (session.state !== "active") {
+          cancelledByClient = true;
+          break;
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          const endMsg = {
+            type: import_protocol.MessageType.RESPONSE_STREAM_END,
+            requestId,
+            streamId
+          };
+          sendMessage(connection.socket, endMsg);
+          break;
+        }
+        for (let offset = 0;offset < value.length; offset += import_protocol.STREAM_CHUNK_SIZE) {
+          const chunk = value.slice(offset, offset + import_protocol.STREAM_CHUNK_SIZE);
+          const chunkMsg = {
+            type: import_protocol.MessageType.RESPONSE_STREAM_CHUNK,
+            requestId,
+            streamId,
+            chunk
+          };
+          sendMessage(connection.socket, chunkMsg);
+          const creditCost = Math.max(chunk.length, import_protocol.STREAM_CHUNK_SIZE);
+          session.credit -= creditCost;
+          session.bytesTransferred += chunk.length;
+          bytesSinceYield += chunk.length;
+          chunksSinceYield += 1;
+          if (chunk.length < 1024 || bytesSinceYield >= SEND_LOOP_YIELD_BYTES || chunksSinceYield >= 256) {
+            bytesSinceYield = 0;
+            chunksSinceYield = 0;
+            await new Promise((resolve) => setImmediate(resolve));
+            if (session.state !== "active") {
+              cancelledByClient = true;
+              break streamLoop;
+            }
+          }
+        }
+      }
+  } catch (err) {
+    if (cancelledByClient || session.state !== "active") {
+      return;
+    }
+    const errorMsg = {
+      type: import_protocol.MessageType.STREAM_ERROR,
+      streamId,
+      error: err.message
+    };
+    sendMessage(connection.socket, errorMsg);
+  } finally {
+    if (cancelledByClient) {
+      await Promise.race([
+        reader.cancel("Stream cancelled by client").catch(() => {}),
+        new Promise((resolve) => setTimeout(resolve, 50))
+      ]);
+    }
+    session.cancelReader = undefined;
+    reader.releaseLock();
+    closeActiveDownloadSession(connection, streamId);
+  }
+}
+async function handleRunTests(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    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_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+      }
+    }
+    return;
+  }
+  try {
+    const runPromise = instance.runtime.testEnvironment.runTests(message.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;
+    if (isRuntimeTimeoutError(error)) {
+      instance.isPoisoned = true;
+    }
+    const currentConn = instance.callbackContext?.connection ?? connection;
+    sendError(currentConn.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleResetTestEnv(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.testEnvironment.reset();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleHasTests(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const result = instance.runtime.testEnvironment.hasTests();
+    sendOk(connection.socket, message.requestId, result);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleGetTestCount(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const result = instance.runtime.testEnvironment.getTestCount();
+    sendOk(connection.socket, message.requestId, result);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleGetCollectedData(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    const data = instance.runtime.playwright.getCollectedData();
+    sendOk(connection.socket, message.requestId, data);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+async function handleClearCollectedData(message, connection, state) {
+  const instance = state.isolates.get(message.isolateId);
+  if (!instance) {
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
+    return;
+  }
+  instance.lastActivity = Date.now();
+  try {
+    instance.runtime.playwright.clearCollectedData();
+    sendOk(connection.socket, message.requestId);
+  } catch (err) {
+    const error = err;
+    sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  }
+}
+
+//# debugId=16FDF3C30EC7DFD264756E2164756E21