@ricsam/isolate 0.0.1 → 0.1.1

package/dist/cjs/internal/client/connection.cjs

@@ -0,0 +1,1919 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+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/client/connection.ts
+var exports_connection = {};
+__export(exports_connection, {
+  isBenignDisposeError: () => isBenignDisposeError,
+  connect: () => connect
+});
+module.exports = __toCommonJS(exports_connection);
+var import_node_net = require("node:net");
+var import_node_path = __toESM(require("node:path"));
+var import_request_context = require("../../bridge/request-context.cjs");
+var import_protocol = require("../protocol/index.cjs");
+var import_client = require("../playwright/client.cjs");
+var isolateWsCallbacks = new Map;
+var isolateClientWebSockets = new Map;
+var isolateWebSocketCallbacks = new Map;
+var isolateEventListeners = new Map;
+async function connect(options = {}) {
+  const socket = await createSocket(options);
+  const state = {
+    socket,
+    pendingRequests: new Map,
+    callbacks: new Map,
+    callbacksNeedingRequestId: new Set,
+    nextRequestId: 1,
+    nextCallbackId: 1,
+    nextStreamId: 1,
+    connected: true,
+    streamResponses: new Map,
+    uploadStreams: new Map,
+    moduleSourceCache: new Map,
+    callbackStreamReaders: new Map,
+    activeCallbackInvocations: new Map,
+    callbackAbortControllers: new Map,
+    closing: false,
+    namespacedRuntimes: new Map
+  };
+  function setupSocket(sock) {
+    const parser = import_protocol.createFrameParser();
+    sock.on("data", (data) => {
+      try {
+        for (const frame of parser.feed(new Uint8Array(data))) {
+          handleMessage(frame.message, state);
+        }
+      } catch (err) {
+        console.error("Error parsing frame:", err);
+      }
+    });
+    sock.on("close", () => {
+      state.connected = false;
+      for (const [, pending] of state.pendingRequests) {
+        pending.reject(new Error("Connection closed"));
+      }
+      state.pendingRequests.clear();
+      for (const [, receiver] of state.streamResponses) {
+        receiver.state = "errored";
+        receiver.error = new Error("Connection closed");
+        const resolvers = receiver.pullResolvers.splice(0);
+        for (const resolver of resolvers) {
+          resolver();
+        }
+      }
+      state.streamResponses.clear();
+      for (const [, session] of state.uploadStreams) {
+        session.state = "closed";
+        if (session.creditResolver) {
+          session.creditResolver();
+        }
+      }
+      state.uploadStreams.clear();
+      for (const [, controller] of state.callbackAbortControllers) {
+        controller.abort();
+      }
+      state.callbackAbortControllers.clear();
+      state.activeCallbackInvocations.clear();
+      if (!state.closing && state.namespacedRuntimes.size > 0) {
+        state.reconnecting = reconnect(state, options).catch(() => {
+          state.namespacedRuntimes.clear();
+          state.reconnecting = undefined;
+        });
+      }
+    });
+    sock.on("error", (err) => {
+      if (!state.closing && state.namespacedRuntimes.size > 0)
+        return;
+      console.error("Socket error:", err);
+    });
+  }
+  setupSocket(socket);
+  async function reconnect(st, opts) {
+    try {
+      const newSocket = await createSocket(opts);
+      st.socket = newSocket;
+      st.connected = true;
+      setupSocket(newSocket);
+      for (const [namespaceId, descriptor] of st.namespacedRuntimes) {
+        const runtimeOptions = descriptor.runtimeOptions;
+        const callbacks = {};
+        if (runtimeOptions.console) {
+          callbacks.console = registerConsoleCallbacks(st, runtimeOptions.console);
+        }
+        if (runtimeOptions.fetch) {
+          callbacks.fetch = registerFetchCallback(st, runtimeOptions.fetch);
+        }
+        if (runtimeOptions.fs) {
+          callbacks.fs = registerFsCallbacks(st, runtimeOptions.fs);
+        }
+        if (runtimeOptions.moduleLoader) {
+          callbacks.moduleLoader = registerModuleLoaderCallback(st, runtimeOptions.moduleLoader);
+        }
+        if (runtimeOptions.customFunctions) {
+          callbacks.custom = registerCustomFunctions(st, runtimeOptions.customFunctions);
+        }
+        if (runtimeOptions.playwright) {
+          const playwrightHandler = runtimeOptions.playwright.handler;
+          if (playwrightHandler) {
+            const handlerCallbackId = st.nextCallbackId++;
+            st.callbacks.set(handlerCallbackId, async (opJson) => {
+              const op = JSON.parse(opJson);
+              const result2 = await playwrightHandler(op);
+              return JSON.stringify(result2);
+            });
+            callbacks.playwright = {
+              handlerCallbackId,
+              console: runtimeOptions.playwright.console && !runtimeOptions.console?.onEntry
+            };
+          }
+        }
+        let testEnvironmentOption;
+        if (runtimeOptions.testEnvironment) {
+          if (typeof runtimeOptions.testEnvironment === "object") {
+            const testEnvOptions = runtimeOptions.testEnvironment;
+            const testEnvCallbacks = {};
+            if (testEnvOptions.onEvent) {
+              const userOnEvent = testEnvOptions.onEvent;
+              const onEventCallbackId = registerEventCallback(st, (eventJson) => {
+                const event = JSON.parse(eventJson);
+                userOnEvent(event);
+              });
+              testEnvCallbacks.onEvent = {
+                callbackId: onEventCallbackId,
+                name: "testEnvironment.onEvent",
+                type: "sync"
+              };
+            }
+            testEnvironmentOption = {
+              callbacks: testEnvCallbacks,
+              testTimeout: testEnvOptions.testTimeout
+            };
+          } else {
+            testEnvironmentOption = true;
+          }
+        }
+        const playwrightOption = runtimeOptions.playwright?.timeout !== undefined ? { timeout: runtimeOptions.playwright.timeout } : undefined;
+        const requestId = st.nextRequestId++;
+        const request = {
+          type: import_protocol.MessageType.CREATE_RUNTIME,
+          requestId,
+          options: {
+            memoryLimitMB: runtimeOptions.memoryLimitMB,
+            executionTimeout: runtimeOptions.executionTimeout,
+            cwd: runtimeOptions.cwd,
+            callbacks,
+            testEnvironment: testEnvironmentOption,
+            playwright: playwrightOption,
+            namespaceId
+          }
+        };
+        const result = await sendRequest(st, request);
+        descriptor.isolateId = result.isolateId;
+      }
+      st.reconnecting = undefined;
+    } catch {
+      st.reconnecting = undefined;
+      throw new Error("Failed to reconnect to daemon");
+    }
+  }
+  return {
+    createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions),
+    createNamespace: (id) => ({
+      id,
+      createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions, id)
+    }),
+    close: async () => {
+      state.closing = true;
+      state.connected = false;
+      state.socket.destroy();
+    },
+    isConnected: () => state.connected
+  };
+}
+function createSocket(options) {
+  return new Promise((resolve, reject) => {
+    const timeout = options.timeout;
+    let socket;
+    const onError = (err) => {
+      reject(err);
+    };
+    const onConnect = () => {
+      socket.removeListener("error", onError);
+      resolve(socket);
+    };
+    if (options.socket) {
+      socket = import_node_net.connect(options.socket, onConnect);
+    } else {
+      socket = import_node_net.connect(options.port ?? 47891, options.host ?? "127.0.0.1", onConnect);
+    }
+    socket.on("error", onError);
+    if (timeout && timeout > 0) {
+      const timeoutId = setTimeout(() => {
+        socket.destroy();
+        reject(new Error("Connection timeout"));
+      }, timeout);
+      socket.once("connect", () => {
+        clearTimeout(timeoutId);
+      });
+    }
+  });
+}
+function handleMessage(message, state) {
+  switch (message.type) {
+    case import_protocol.MessageType.RESPONSE_OK: {
+      const response = message;
+      const pending = state.pendingRequests.get(response.requestId);
+      if (pending) {
+        state.pendingRequests.delete(response.requestId);
+        pending.resolve(response.data);
+      }
+      break;
+    }
+    case import_protocol.MessageType.RESPONSE_ERROR: {
+      const response = message;
+      const pending = state.pendingRequests.get(response.requestId);
+      if (pending) {
+        state.pendingRequests.delete(response.requestId);
+        const error = new Error(response.message);
+        if (response.details) {
+          error.name = response.details.name;
+          if (response.details.stack) {
+            error.stack = response.details.stack;
+          }
+        }
+        pending.reject(error);
+      }
+      break;
+    }
+    case import_protocol.MessageType.CALLBACK_INVOKE: {
+      const invoke = message;
+      handleCallbackInvoke(invoke, state);
+      break;
+    }
+    case import_protocol.MessageType.PONG:
+      break;
+    case import_protocol.MessageType.CALLBACK_STREAM_CANCEL: {
+      const streamId = message.streamId;
+      const reader = state.callbackStreamReaders.get(streamId);
+      if (reader) {
+        reader.cancel().catch(() => {});
+      }
+      break;
+    }
+    case import_protocol.MessageType.CALLBACK_ABORT: {
+      const msg = message;
+      const invocation = state.activeCallbackInvocations.get(msg.targetRequestId);
+      if (invocation) {
+        invocation.aborted = true;
+      }
+      const controller = state.callbackAbortControllers.get(msg.targetRequestId);
+      if (controller && !controller.signal.aborted) {
+        controller.abort();
+      }
+      break;
+    }
+    case import_protocol.MessageType.ISOLATE_EVENT: {
+      const msg = message;
+      handleIsolateEvent(msg, state);
+      break;
+    }
+    case import_protocol.MessageType.RESPONSE_STREAM_START: {
+      const msg = message;
+      const receiver = {
+        streamId: msg.streamId,
+        requestId: msg.requestId,
+        metadata: msg.metadata,
+        controller: null,
+        state: "active",
+        pendingChunks: [],
+        pullResolvers: [],
+        controllerFinalized: false
+      };
+      const readableStream = new ReadableStream({
+        start(controller) {
+          receiver.controller = controller;
+        },
+        pull(_controller) {
+          if (receiver.controllerFinalized) {
+            return;
+          }
+          while (receiver.pendingChunks.length > 0) {
+            const chunk = receiver.pendingChunks.shift();
+            receiver.controller.enqueue(chunk);
+          }
+          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();
+          }
+          sendMessage(state.socket, {
+            type: import_protocol.MessageType.STREAM_PULL,
+            streamId: msg.streamId,
+            maxBytes: import_protocol.STREAM_DEFAULT_CREDIT
+          });
+          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();
+          }
+          sendMessage(state.socket, {
+            type: import_protocol.MessageType.STREAM_ERROR,
+            streamId: msg.streamId,
+            error: "Stream cancelled by consumer"
+          });
+          state.streamResponses.delete(msg.streamId);
+          return new Promise((resolve) => setTimeout(resolve, 0));
+        }
+      });
+      state.streamResponses.set(msg.streamId, receiver);
+      const pending = state.pendingRequests.get(msg.requestId);
+      if (pending) {
+        state.pendingRequests.delete(msg.requestId);
+        const response = new Response(readableStream, {
+          status: msg.metadata?.status ?? 200,
+          statusText: msg.metadata?.statusText ?? "OK",
+          headers: msg.metadata?.headers
+        });
+        pending.resolve({ response, __streaming: true });
+      }
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.STREAM_PULL,
+        streamId: msg.streamId,
+        maxBytes: import_protocol.STREAM_DEFAULT_CREDIT
+      });
+      break;
+    }
+    case import_protocol.MessageType.RESPONSE_STREAM_CHUNK: {
+      const msg = message;
+      const receiver = state.streamResponses.get(msg.streamId);
+      if (receiver && receiver.state === "active") {
+        if (receiver.pullResolvers.length > 0) {
+          receiver.controller.enqueue(msg.chunk);
+          const resolver = receiver.pullResolvers.shift();
+          resolver();
+        } else {
+          receiver.pendingChunks.push(msg.chunk);
+        }
+      }
+      break;
+    }
+    case import_protocol.MessageType.RESPONSE_STREAM_END: {
+      const msg = message;
+      const receiver = state.streamResponses.get(msg.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();
+        }
+        state.streamResponses.delete(msg.streamId);
+      }
+      break;
+    }
+    case import_protocol.MessageType.STREAM_PULL: {
+      const msg = message;
+      const session = state.uploadStreams.get(msg.streamId);
+      if (session) {
+        session.credit += msg.maxBytes;
+        if (session.creditResolver) {
+          session.creditResolver();
+          session.creditResolver = undefined;
+        }
+      }
+      break;
+    }
+    case import_protocol.MessageType.STREAM_ERROR: {
+      const msg = message;
+      const uploadSession = state.uploadStreams.get(msg.streamId);
+      if (uploadSession) {
+        uploadSession.state = "closed";
+        state.uploadStreams.delete(msg.streamId);
+      }
+      const receiver = state.streamResponses.get(msg.streamId);
+      if (receiver) {
+        receiver.state = "errored";
+        receiver.error = new Error(msg.error);
+        while (receiver.pendingChunks.length > 0) {
+          const chunk = receiver.pendingChunks.shift();
+          receiver.controller.enqueue(chunk);
+        }
+        const resolvers = receiver.pullResolvers.splice(0);
+        for (const resolver of resolvers) {
+          resolver();
+        }
+        state.streamResponses.delete(msg.streamId);
+      }
+      break;
+    }
+    default:
+      console.warn(`Unexpected message type: ${message.type}`);
+  }
+}
+async function handleCallbackInvoke(invoke, state) {
+  const callback = state.callbacks.get(invoke.callbackId);
+  const invocationState = { aborted: false };
+  state.activeCallbackInvocations.set(invoke.requestId, invocationState);
+  const abortController = new AbortController;
+  state.callbackAbortControllers.set(invoke.requestId, abortController);
+  const response = {
+    type: import_protocol.MessageType.CALLBACK_RESPONSE,
+    requestId: invoke.requestId
+  };
+  if (!callback) {
+    response.error = {
+      name: "Error",
+      message: `Unknown callback: ${invoke.callbackId}`
+    };
+    if (!invocationState.aborted) {
+      sendMessage(state.socket, response);
+    }
+    state.activeCallbackInvocations.delete(invoke.requestId);
+    state.callbackAbortControllers.delete(invoke.requestId);
+  } else {
+    try {
+      const invokeRegisteredCallback = async () => {
+        const needsRequestId = state.callbacksNeedingRequestId.has(invoke.callbackId);
+        return needsRequestId ? await callback(...invoke.args, invoke.requestId) : await callback(...invoke.args);
+      };
+      const result = invoke.context ? await import_request_context.withRequestContext({
+        requestId: invoke.context.requestId,
+        metadata: invoke.context.metadata,
+        signal: abortController.signal
+      }, invokeRegisteredCallback) : await import_request_context.withRequestContext({
+        signal: abortController.signal
+      }, invokeRegisteredCallback);
+      if (result && typeof result === "object" && result.__callbackStreaming) {
+        return;
+      }
+      if (invocationState.aborted) {
+        return;
+      }
+      response.result = result;
+      sendMessage(state.socket, response);
+    } catch (err) {
+      if (invocationState.aborted) {
+        return;
+      }
+      const error = err;
+      response.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+      sendMessage(state.socket, response);
+    } finally {
+      state.activeCallbackInvocations.delete(invoke.requestId);
+      state.callbackAbortControllers.delete(invoke.requestId);
+    }
+  }
+}
+function sendMessage(socket, message) {
+  const frame = import_protocol.buildFrame(message);
+  socket.write(frame);
+}
+function sendRequest(state, message) {
+  return new Promise((resolve, reject) => {
+    if (!state.connected) {
+      reject(new Error("Not connected"));
+      return;
+    }
+    const requestId = message.requestId;
+    state.pendingRequests.set(requestId, {
+      resolve,
+      reject
+    });
+    sendMessage(state.socket, message);
+  });
+}
+function isBenignDisposeError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /isolate not owned by this connection|isolate not found|not connected|connection closed/i.test(message);
+}
+function normalizePlaywrightOptions(playwrightOptions) {
+  if (!playwrightOptions || playwrightOptions.timeout === undefined) {
+    return playwrightOptions;
+  }
+  const metadata = import_client.getDefaultPlaywrightHandlerMetadata(playwrightOptions.handler);
+  if (!metadata?.page) {
+    return playwrightOptions;
+  }
+  const currentTimeout = metadata.options?.timeout ?? 30000;
+  if (currentTimeout === playwrightOptions.timeout) {
+    return playwrightOptions;
+  }
+  return {
+    ...playwrightOptions,
+    handler: import_client.defaultPlaywrightHandler(metadata.page, {
+      ...metadata.options,
+      timeout: playwrightOptions.timeout
+    })
+  };
+}
+async function createRuntime(state, options = {}, namespaceId) {
+  const normalizedPlaywrightOptions = normalizePlaywrightOptions(options.playwright);
+  const runtimeOptionsForReconnect = normalizedPlaywrightOptions === options.playwright ? options : {
+    ...options,
+    playwright: normalizedPlaywrightOptions
+  };
+  const callbacks = {};
+  if (options.console) {
+    callbacks.console = registerConsoleCallbacks(state, options.console);
+  }
+  if (options.fetch) {
+    callbacks.fetch = registerFetchCallback(state, options.fetch);
+  }
+  if (options.fs) {
+    callbacks.fs = registerFsCallbacks(state, options.fs);
+  }
+  if (options.moduleLoader) {
+    callbacks.moduleLoader = registerModuleLoaderCallback(state, options.moduleLoader);
+  }
+  if (options.customFunctions) {
+    callbacks.custom = registerCustomFunctions(state, options.customFunctions);
+  }
+  let playwrightHandler;
+  const browserConsoleLogs = [];
+  const pageErrors = [];
+  const networkRequests = [];
+  const networkResponses = [];
+  const requestFailures = [];
+  const pageListenerCleanups = [];
+  if (normalizedPlaywrightOptions) {
+    playwrightHandler = normalizedPlaywrightOptions.handler;
+    if (!playwrightHandler) {
+      throw new Error("playwright.handler is required when using playwright options");
+    }
+    const page = import_client.getDefaultPlaywrightHandlerMetadata(playwrightHandler)?.page;
+    const handlerCallbackId = state.nextCallbackId++;
+    state.callbacks.set(handlerCallbackId, async (opJson) => {
+      const op = JSON.parse(opJson);
+      const result2 = await playwrightHandler(op);
+      return JSON.stringify(result2);
+    });
+    if (page) {
+      const requestIds = new WeakMap;
+      let nextRequestId = 1;
+      const getRequestId = (request2) => {
+        let requestId2 = requestIds.get(request2);
+        if (!requestId2) {
+          requestId2 = `req_${nextRequestId++}`;
+          requestIds.set(request2, requestId2);
+        }
+        return requestId2;
+      };
+      const toLocation = (location) => {
+        if (!location || !location.url && location.lineNumber == null && location.columnNumber == null) {
+          return;
+        }
+        return {
+          url: location.url || undefined,
+          lineNumber: location.lineNumber != null ? location.lineNumber + 1 : undefined,
+          columnNumber: location.columnNumber != null ? location.columnNumber + 1 : undefined
+        };
+      };
+      const onConsole = (msg) => {
+        const entry = {
+          level: msg.type(),
+          stdout: msg.text(),
+          location: toLocation(msg.location()),
+          timestamp: Date.now()
+        };
+        browserConsoleLogs.push(entry);
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent({
+            type: "browserConsoleLog",
+            ...entry
+          });
+        }
+        if (normalizedPlaywrightOptions.console && options.console?.onEntry) {
+          options.console.onEntry({
+            type: "browserOutput",
+            ...entry
+          });
+        } else if (normalizedPlaywrightOptions.console) {
+          const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
+          console.log(prefix, entry.stdout);
+        }
+      };
+      const onRequest = (request2) => {
+        const info = {
+          requestId: getRequestId(request2),
+          url: request2.url(),
+          method: request2.method(),
+          headers: request2.headers(),
+          postData: request2.postData() ?? undefined,
+          resourceType: request2.resourceType(),
+          timestamp: Date.now()
+        };
+        networkRequests.push(info);
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent({
+            type: "networkRequest",
+            ...info
+          });
+        }
+      };
+      const onResponse = (response) => {
+        const request2 = response.request();
+        const info = {
+          requestId: getRequestId(request2),
+          url: response.url(),
+          status: response.status(),
+          statusText: response.statusText(),
+          headers: response.headers(),
+          resourceType: request2.resourceType(),
+          timestamp: Date.now()
+        };
+        networkResponses.push(info);
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent({
+            type: "networkResponse",
+            ...info
+          });
+        }
+      };
+      const onRequestFailed = (request2) => {
+        const info = {
+          requestId: getRequestId(request2),
+          url: request2.url(),
+          method: request2.method(),
+          failureText: request2.failure()?.errorText || "request failed",
+          resourceType: request2.resourceType(),
+          timestamp: Date.now()
+        };
+        requestFailures.push(info);
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent({
+            type: "requestFailure",
+            ...info
+          });
+        }
+      };
+      const onPageError = (error) => {
+        const entry = {
+          name: error.name,
+          message: error.message,
+          stack: error.stack,
+          timestamp: Date.now()
+        };
+        pageErrors.push(entry);
+        if (normalizedPlaywrightOptions.onEvent) {
+          normalizedPlaywrightOptions.onEvent({
+            type: "pageError",
+            ...entry
+          });
+        }
+      };
+      page.on("console", onConsole);
+      page.on("request", onRequest);
+      page.on("response", onResponse);
+      page.on("requestfailed", onRequestFailed);
+      page.on("pageerror", onPageError);
+      pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse), () => page.removeListener("requestfailed", onRequestFailed), () => page.removeListener("pageerror", onPageError));
+    }
+    callbacks.playwright = {
+      handlerCallbackId,
+      console: normalizedPlaywrightOptions.console && !options.console?.onEntry
+    };
+  }
+  let testEnvironmentOption;
+  if (options.testEnvironment) {
+    if (typeof options.testEnvironment === "object") {
+      const testEnvOptions = options.testEnvironment;
+      const testEnvCallbacks = {};
+      if (testEnvOptions.onEvent) {
+        const userOnEvent = testEnvOptions.onEvent;
+        const onEventCallbackId = registerEventCallback(state, (eventJson) => {
+          const event = JSON.parse(eventJson);
+          userOnEvent(event);
+        });
+        testEnvCallbacks.onEvent = {
+          callbackId: onEventCallbackId,
+          name: "testEnvironment.onEvent",
+          type: "sync"
+        };
+      }
+      testEnvironmentOption = {
+        callbacks: testEnvCallbacks,
+        testTimeout: testEnvOptions.testTimeout
+      };
+    } else {
+      testEnvironmentOption = true;
+    }
+  }
+  const playwrightOption = normalizedPlaywrightOptions?.timeout !== undefined ? { timeout: normalizedPlaywrightOptions.timeout } : undefined;
+  const requestId = state.nextRequestId++;
+  const request = {
+    type: import_protocol.MessageType.CREATE_RUNTIME,
+    requestId,
+    options: {
+      memoryLimitMB: options.memoryLimitMB,
+      executionTimeout: options.executionTimeout,
+      cwd: options.cwd,
+      callbacks,
+      testEnvironment: testEnvironmentOption,
+      playwright: playwrightOption,
+      namespaceId
+    }
+  };
+  const result = await sendRequest(state, request);
+  const isolateId = result.isolateId;
+  const reused = result.reused ?? false;
+  if (namespaceId != null) {
+    state.namespacedRuntimes.set(namespaceId, {
+      isolateId,
+      runtimeOptions: runtimeOptionsForReconnect
+    });
+  }
+  const wsCommandCallbacks = new Set;
+  isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
+  if (options.onWebSocketCommand) {
+    wsCommandCallbacks.add(options.onWebSocketCommand);
+  }
+  if (options.webSocket) {
+    isolateWebSocketCallbacks.set(isolateId, options.webSocket);
+  }
+  const fetchHandle = {
+    async dispatchRequest(req, opts) {
+      const signal = opts?.signal;
+      const requestSignal = req.signal;
+      const requestSignalInitiallyAborted = requestSignal?.aborted ?? false;
+      const reqId = state.nextRequestId++;
+      const serialized = await serializeRequestWithStreaming(state, req);
+      const { bodyStream, ...serializableRequest } = serialized;
+      const request2 = {
+        type: import_protocol.MessageType.DISPATCH_REQUEST,
+        requestId: reqId,
+        isolateId,
+        request: serializableRequest,
+        context: opts?.requestId || opts?.metadata ? {
+          requestId: opts.requestId,
+          metadata: opts.metadata
+        } : undefined
+      };
+      const handleResponse = (res) => {
+        if (res.__streaming && res.response instanceof Response) {
+          return res.response;
+        }
+        return import_protocol.deserializeResponse(res.response);
+      };
+      let abortSent = false;
+      const sendAbort = () => {
+        if (abortSent) {
+          return;
+        }
+        abortSent = true;
+        const abortMessage = {
+          type: import_protocol.MessageType.DISPATCH_REQUEST_ABORT,
+          isolateId,
+          targetRequestId: reqId
+        };
+        if (state.connected) {
+          sendMessage(state.socket, abortMessage);
+        }
+      };
+      let onAbort;
+      if (signal) {
+        onAbort = sendAbort;
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+          sendAbort();
+        }
+      }
+      let onRequestAbort;
+      if (requestSignal && !requestSignalInitiallyAborted) {
+        onRequestAbort = sendAbort;
+        requestSignal.addEventListener("abort", onRequestAbort, { once: true });
+        if (requestSignal.aborted) {
+          sendAbort();
+        }
+      }
+      request2.request.signalAborted = (request2.request.signalAborted ?? false) || signal?.aborted === true;
+      try {
+        if (serialized.bodyStreamId !== undefined && bodyStream) {
+          const streamId = serialized.bodyStreamId;
+          const responsePromise = sendRequest(state, request2);
+          await sendBodyStream(state, streamId, bodyStream);
+          const res = await responsePromise;
+          return handleResponse(res);
+        } else {
+          const res = await sendRequest(state, request2);
+          return handleResponse(res);
+        }
+      } finally {
+        if (signal && onAbort) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        if (requestSignal && onRequestAbort) {
+          requestSignal.removeEventListener("abort", onRequestAbort);
+        }
+      }
+    },
+    async getUpgradeRequest() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.FETCH_GET_UPGRADE_REQUEST,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async dispatchWebSocketOpen(connectionId) {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.WS_OPEN,
+        requestId: reqId,
+        isolateId,
+        connectionId
+      };
+      await sendRequest(state, req);
+    },
+    async dispatchWebSocketMessage(connectionId, message) {
+      const reqId = state.nextRequestId++;
+      const data = message instanceof ArrayBuffer ? new Uint8Array(message) : message;
+      const req = {
+        type: import_protocol.MessageType.WS_MESSAGE,
+        requestId: reqId,
+        isolateId,
+        connectionId,
+        data
+      };
+      await sendRequest(state, req);
+    },
+    async dispatchWebSocketClose(connectionId, code, reason) {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.WS_CLOSE,
+        requestId: reqId,
+        isolateId,
+        connectionId,
+        code,
+        reason
+      };
+      await sendRequest(state, req);
+    },
+    async dispatchWebSocketError(connectionId, error) {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.FETCH_WS_ERROR,
+        requestId: reqId,
+        isolateId,
+        connectionId,
+        error: error.message
+      };
+      await sendRequest(state, req);
+    },
+    onWebSocketCommand(callback) {
+      wsCommandCallbacks.add(callback);
+      return () => {
+        wsCommandCallbacks.delete(callback);
+      };
+    },
+    async hasServeHandler() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.FETCH_HAS_SERVE_HANDLER,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async hasActiveConnections() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.FETCH_HAS_ACTIVE_CONNECTIONS,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    }
+  };
+  const timersHandle = {
+    async clearAll() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.TIMERS_CLEAR_ALL,
+        requestId: reqId,
+        isolateId
+      };
+      await sendRequest(state, req);
+    }
+  };
+  const consoleHandle = {
+    async reset() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.CONSOLE_RESET,
+        requestId: reqId,
+        isolateId
+      };
+      await sendRequest(state, req);
+    },
+    async getTimers() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.CONSOLE_GET_TIMERS,
+        requestId: reqId,
+        isolateId
+      };
+      const result2 = await sendRequest(state, req);
+      return new Map(Object.entries(result2));
+    },
+    async getCounters() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.CONSOLE_GET_COUNTERS,
+        requestId: reqId,
+        isolateId
+      };
+      const result2 = await sendRequest(state, req);
+      return new Map(Object.entries(result2));
+    },
+    async getGroupDepth() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.CONSOLE_GET_GROUP_DEPTH,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    }
+  };
+  const testEnvironmentEnabled = !!options.testEnvironment;
+  const playwrightEnabled = !!normalizedPlaywrightOptions;
+  const testEnvironmentHandle = {
+    async runTests(timeout) {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.RUN_TESTS,
+        requestId: reqId,
+        isolateId,
+        timeout
+      };
+      try {
+        return await sendRequest(state, req);
+      } catch (err) {
+        if (err instanceof Error && /connection closed|not connected/i.test(err.message) && state.reconnecting) {
+          await state.reconnecting;
+          const retryReqId = state.nextRequestId++;
+          const retryReq = {
+            type: import_protocol.MessageType.RUN_TESTS,
+            requestId: retryReqId,
+            isolateId,
+            timeout
+          };
+          return sendRequest(state, retryReq);
+        }
+        throw err;
+      }
+    },
+    async hasTests() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.HAS_TESTS,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async getTestCount() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.GET_TEST_COUNT,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async reset() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.RESET_TEST_ENV,
+        requestId: reqId,
+        isolateId
+      };
+      await sendRequest(state, req);
+    }
+  };
+  const playwrightHandle = {
+    getCollectedData() {
+      if (!playwrightEnabled) {
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
+      }
+      return {
+        browserConsoleLogs: [...browserConsoleLogs],
+        pageErrors: [...pageErrors],
+        networkRequests: [...networkRequests],
+        networkResponses: [...networkResponses],
+        requestFailures: [...requestFailures]
+      };
+    },
+    clearCollectedData() {
+      if (!playwrightEnabled) {
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
+      }
+      browserConsoleLogs.length = 0;
+      pageErrors.length = 0;
+      networkRequests.length = 0;
+      networkResponses.length = 0;
+      requestFailures.length = 0;
+    }
+  };
+  return {
+    id: isolateId,
+    reused,
+    fetch: fetchHandle,
+    timers: timersHandle,
+    console: consoleHandle,
+    testEnvironment: testEnvironmentHandle,
+    playwright: playwrightHandle,
+    eval: async (code, filenameOrOptions) => {
+      const reqId = state.nextRequestId++;
+      const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+      const req = {
+        type: import_protocol.MessageType.EVAL,
+        requestId: reqId,
+        isolateId,
+        code,
+        filename: options2?.filename,
+        executionTimeout: options2?.executionTimeout
+      };
+      await sendRequest(state, req);
+    },
+    on(event, callback) {
+      let listeners = isolateEventListeners.get(isolateId);
+      if (!listeners) {
+        listeners = new Map;
+        isolateEventListeners.set(isolateId, listeners);
+      }
+      let eventListeners = listeners.get(event);
+      if (!eventListeners) {
+        eventListeners = new Set;
+        listeners.set(event, eventListeners);
+      }
+      eventListeners.add(callback);
+      return () => {
+        eventListeners.delete(callback);
+        if (eventListeners.size === 0) {
+          listeners.delete(event);
+          if (listeners.size === 0) {
+            isolateEventListeners.delete(isolateId);
+          }
+        }
+      };
+    },
+    emit(event, payload) {
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event,
+        payload
+      });
+    },
+    dispose: async (options2) => {
+      for (const cleanup of pageListenerCleanups) {
+        cleanup();
+      }
+      isolateWsCallbacks.delete(isolateId);
+      isolateWebSocketCallbacks.delete(isolateId);
+      isolateEventListeners.delete(isolateId);
+      const clientSockets = isolateClientWebSockets.get(isolateId);
+      if (clientSockets) {
+        for (const ws of clientSockets.values()) {
+          if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+            ws.close(1000, "Isolate disposed");
+          }
+        }
+        isolateClientWebSockets.delete(isolateId);
+      }
+      if (namespaceId != null) {
+        state.namespacedRuntimes.delete(namespaceId);
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_protocol.MessageType.DISPOSE_RUNTIME,
+        requestId: reqId,
+        isolateId,
+        hard: options2?.hard === true ? true : undefined,
+        reason: typeof options2?.reason === "string" && options2.reason.length > 0 ? options2.reason : undefined
+      };
+      try {
+        await sendRequest(state, req);
+      } catch (error) {
+        if (!isBenignDisposeError(error)) {
+          throw error;
+        }
+      }
+    }
+  };
+}
+function registerEventCallback(state, handler) {
+  const callbackId = state.nextCallbackId++;
+  state.callbacks.set(callbackId, (data) => {
+    handler(data);
+    return;
+  });
+  return callbackId;
+}
+function registerConsoleCallbacks(state, callbacks) {
+  const registrations = {};
+  if (callbacks.onEntry) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, (entry) => {
+      callbacks.onEntry(entry);
+    });
+    registrations.onEntry = { callbackId, name: "onEntry", type: "sync" };
+  }
+  return registrations;
+}
+var CALLBACK_STREAM_THRESHOLD = 64 * 1024;
+var NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+function registerFetchCallback(state, callback) {
+  const callbackId = state.nextCallbackId++;
+  state.callbacksNeedingRequestId.add(callbackId);
+  state.callbacks.set(callbackId, async (serialized, requestId) => {
+    const data = serialized;
+    const requestContext = import_request_context.getRequestContext();
+    const signalController = new AbortController;
+    const onContextAbort = () => {
+      if (!signalController.signal.aborted) {
+        signalController.abort(requestContext.signal?.reason ?? Object.assign(new Error("The operation was aborted."), {
+          name: "AbortError"
+        }));
+      }
+    };
+    if (requestContext.signal) {
+      requestContext.signal.addEventListener("abort", onContextAbort, {
+        once: true
+      });
+      if (requestContext.signal.aborted) {
+        onContextAbort();
+      }
+    }
+    if (data.signalAborted) {
+      signalController.abort();
+    }
+    try {
+      const init = {
+        method: data.method,
+        headers: data.headers,
+        rawBody: data.body ?? null,
+        body: data.body ?? null,
+        signal: signalController.signal
+      };
+      const response = await callback(data.url, init);
+      const contentLength = response.headers.get("content-length");
+      const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+      const isNetworkResponse = response.url && (response.url.startsWith("http://") || response.url.startsWith("https://"));
+      const shouldStream = isNetworkResponse && !NULL_BODY_STATUSES.has(response.status) && !!response.body && (knownSize === null || knownSize > CALLBACK_STREAM_THRESHOLD);
+      if (shouldStream && response.body) {
+        const streamId = state.nextStreamId++;
+        const headers = [];
+        response.headers.forEach((value, key) => {
+          headers.push([key, value]);
+        });
+        sendMessage(state.socket, {
+          type: import_protocol.MessageType.CALLBACK_STREAM_START,
+          requestId,
+          streamId,
+          metadata: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            url: response.url || undefined
+          }
+        });
+        streamCallbackResponseBody(state, streamId, requestId, response.body);
+        return { __callbackStreaming: true, streamId };
+      }
+      return import_protocol.serializeResponse(response);
+    } finally {
+      if (requestContext.signal) {
+        requestContext.signal.removeEventListener("abort", onContextAbort);
+      }
+    }
+  });
+  return { callbackId, name: "fetch", type: "async" };
+}
+async function streamCallbackResponseBody(state, streamId, requestId, body) {
+  const reader = body.getReader();
+  state.callbackStreamReaders.set(streamId, reader);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        sendMessage(state.socket, {
+          type: import_protocol.MessageType.CALLBACK_STREAM_END,
+          requestId,
+          streamId
+        });
+        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);
+        sendMessage(state.socket, {
+          type: import_protocol.MessageType.CALLBACK_STREAM_CHUNK,
+          requestId,
+          streamId,
+          chunk
+        });
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof Error && err.message.includes("cancel"))) {
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.STREAM_ERROR,
+        streamId,
+        error: err.message
+      });
+    }
+  } finally {
+    state.callbackStreamReaders.delete(streamId);
+    reader.releaseLock();
+  }
+}
+function registerFsCallbacks(state, callbacks) {
+  const registrations = {};
+  if (callbacks.readFile) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2) => {
+      const result = await callbacks.readFile(path2);
+      return new Uint8Array(result);
+    });
+    registrations.readFile = { callbackId, name: "readFile", type: "async" };
+  }
+  if (callbacks.writeFile) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2, data) => {
+      let buffer;
+      if (data instanceof Uint8Array) {
+        buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      } else if (Array.isArray(data)) {
+        buffer = new Uint8Array(data).buffer;
+      } else if (data instanceof ArrayBuffer) {
+        buffer = data;
+      } else {
+        buffer = new ArrayBuffer(0);
+      }
+      await callbacks.writeFile(path2, buffer);
+    });
+    registrations.writeFile = { callbackId, name: "writeFile", type: "async" };
+  }
+  if (callbacks.unlink) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.unlink(path2);
+    });
+    registrations.unlink = { callbackId, name: "unlink", type: "async" };
+  }
+  if (callbacks.readdir) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.readdir(path2);
+    });
+    registrations.readdir = { callbackId, name: "readdir", type: "async" };
+  }
+  if (callbacks.mkdir) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2, options) => {
+      await callbacks.mkdir(path2, options);
+    });
+    registrations.mkdir = { callbackId, name: "mkdir", type: "async" };
+  }
+  if (callbacks.rmdir) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.rmdir(path2);
+    });
+    registrations.rmdir = { callbackId, name: "rmdir", type: "async" };
+  }
+  if (callbacks.stat) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.stat(path2);
+    });
+    registrations.stat = { callbackId, name: "stat", type: "async" };
+  }
+  if (callbacks.rename) {
+    const callbackId = state.nextCallbackId++;
+    state.callbacks.set(callbackId, async (from, to) => {
+      await callbacks.rename(from, to);
+    });
+    registrations.rename = { callbackId, name: "rename", type: "async" };
+  }
+  return registrations;
+}
+function registerModuleLoaderCallback(state, callback) {
+  const callbackId = state.nextCallbackId++;
+  state.callbacks.set(callbackId, async (moduleName, importer) => {
+    const specifier = moduleName;
+    const importerInfo = importer;
+    const result = await callback(specifier, importerInfo);
+    const resolvedPath = import_node_path.default.posix.join(result.resolveDir, result.filename);
+    state.moduleSourceCache.set(resolvedPath, result.code);
+    return result;
+  });
+  return { callbackId, name: "moduleLoader", type: "async" };
+}
+var clientIteratorSessions = new Map;
+var nextClientIteratorId = 1;
+var returnedPromiseRegistry = new Map;
+var returnedIteratorRegistry = new Map;
+function registerCustomFunctions(state, customFunctions) {
+  const registrations = {};
+  for (const [name, def] of Object.entries(customFunctions)) {
+    if (def.type === "asyncIterator") {
+      const startCallbackId = state.nextCallbackId++;
+      state.callbacks.set(startCallbackId, async (...args) => {
+        try {
+          const fn = def.fn;
+          const iterator = fn(...args);
+          const iteratorId = nextClientIteratorId++;
+          clientIteratorSessions.set(iteratorId, { iterator });
+          return { iteratorId };
+        } catch (error) {
+          throw error;
+        }
+      });
+      const nextCallbackId = state.nextCallbackId++;
+      state.callbacks.set(nextCallbackId, async (iteratorId) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          throw new Error(`Iterator session ${iteratorId} not found`);
+        }
+        try {
+          const result = await session.iterator.next();
+          if (result.done) {
+            clientIteratorSessions.delete(iteratorId);
+          }
+          return { done: result.done, value: await import_protocol.marshalValue(result.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      const returnCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnCallbackId, async (iteratorId, value) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          return { done: true, value: await import_protocol.marshalValue(undefined) };
+        }
+        try {
+          const result = await session.iterator.return?.(value);
+          clientIteratorSessions.delete(iteratorId);
+          return { done: true, value: await import_protocol.marshalValue(result?.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      const throwCallbackId = state.nextCallbackId++;
+      state.callbacks.set(throwCallbackId, async (iteratorId, errorData) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          throw new Error(`Iterator session ${iteratorId} not found`);
+        }
+        try {
+          const errInfo = errorData;
+          const error = Object.assign(new Error(errInfo.message), { name: errInfo.name });
+          const result = await session.iterator.throw?.(error);
+          clientIteratorSessions.delete(iteratorId);
+          return { done: result?.done ?? true, value: await import_protocol.marshalValue(result?.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      registrations[`${name}:start`] = { callbackId: startCallbackId, name: `${name}:start`, type: "async" };
+      registrations[`${name}:next`] = { callbackId: nextCallbackId, name: `${name}:next`, type: "async" };
+      registrations[`${name}:return`] = { callbackId: returnCallbackId, name: `${name}:return`, type: "async" };
+      registrations[`${name}:throw`] = { callbackId: throwCallbackId, name: `${name}:throw`, type: "async" };
+      registrations[name] = {
+        callbackId: startCallbackId,
+        name,
+        type: "asyncIterator"
+      };
+    } else {
+      const callbackId = state.nextCallbackId++;
+      state.callbacks.set(callbackId, async (...args) => {
+        const result = await def.fn(...args);
+        const addCallbackIdsToRefs = (value) => {
+          if (value === null || typeof value !== "object") {
+            return value;
+          }
+          if (import_protocol.isPromiseRef(value)) {
+            const resolveCallbackId = state.nextCallbackId++;
+            state.callbacks.set(resolveCallbackId, async (...args2) => {
+              const promiseId = args2[0];
+              const promise = returnedPromiseRegistry.get(promiseId);
+              if (!promise) {
+                throw new Error(`Promise ${promiseId} not found`);
+              }
+              const promiseResult = await promise;
+              returnedPromiseRegistry.delete(promiseId);
+              const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
+              return addCallbackIdsToRefs(marshalledResult);
+            });
+            return {
+              ...value,
+              __resolveCallbackId: resolveCallbackId
+            };
+          }
+          if (import_protocol.isAsyncIteratorRef(value)) {
+            const nextCallbackId = state.nextCallbackId++;
+            state.callbacks.set(nextCallbackId, async (...args2) => {
+              const iteratorId = args2[0];
+              const iterator = returnedIteratorRegistry.get(iteratorId);
+              if (!iterator) {
+                throw new Error(`Iterator ${iteratorId} not found`);
+              }
+              const iterResult = await iterator.next();
+              if (iterResult.done) {
+                returnedIteratorRegistry.delete(iteratorId);
+              }
+              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+              return {
+                done: iterResult.done,
+                value: addCallbackIdsToRefs(marshalledValue)
+              };
+            });
+            const returnCallbackId = state.nextCallbackId++;
+            state.callbacks.set(returnCallbackId, async (...args2) => {
+              const iteratorId = args2[0];
+              const returnValue = args2[1];
+              const iterator = returnedIteratorRegistry.get(iteratorId);
+              returnedIteratorRegistry.delete(iteratorId);
+              if (!iterator || !iterator.return) {
+                return { done: true, value: undefined };
+              }
+              const iterResult = await iterator.return(returnValue);
+              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+              return {
+                done: true,
+                value: addCallbackIdsToRefs(marshalledValue)
+              };
+            });
+            const throwCallbackId = state.nextCallbackId++;
+            state.callbacks.set(throwCallbackId, async (...args2) => {
+              const iteratorId = args2[0];
+              const errorValue = args2[1];
+              const iterator = returnedIteratorRegistry.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 iterResult = await iterator.throw(thrownError);
+                if (iterResult.done) {
+                  returnedIteratorRegistry.delete(iteratorId);
+                }
+                const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+                return {
+                  done: iterResult.done,
+                  value: addCallbackIdsToRefs(marshalledValue)
+                };
+              } catch (error) {
+                returnedIteratorRegistry.delete(iteratorId);
+                throw error;
+              }
+            });
+            return {
+              ...value,
+              __nextCallbackId: nextCallbackId,
+              __returnCallbackId: returnCallbackId,
+              __throwCallbackId: throwCallbackId
+            };
+          }
+          if (Array.isArray(value)) {
+            return value.map((item) => addCallbackIdsToRefs(item));
+          }
+          const objResult = {};
+          for (const key of Object.keys(value)) {
+            objResult[key] = addCallbackIdsToRefs(value[key]);
+          }
+          return objResult;
+        };
+        const marshalCtx = {
+          registerCallback: (fn) => {
+            const returnedCallbackId = state.nextCallbackId++;
+            state.callbacks.set(returnedCallbackId, async (...args2) => {
+              const fnResult = await fn(...args2);
+              const marshalledResult = await import_protocol.marshalValue(fnResult, marshalCtx);
+              return addCallbackIdsToRefs(marshalledResult);
+            });
+            return returnedCallbackId;
+          },
+          registerPromise: (promise) => {
+            const promiseId = state.nextCallbackId++;
+            returnedPromiseRegistry.set(promiseId, promise);
+            return promiseId;
+          },
+          registerIterator: (iterator) => {
+            const iteratorId = state.nextCallbackId++;
+            returnedIteratorRegistry.set(iteratorId, iterator);
+            return iteratorId;
+          }
+        };
+        const marshalled = await import_protocol.marshalValue(result, marshalCtx);
+        const withCallbackIds = addCallbackIdsToRefs(marshalled);
+        return withCallbackIds;
+      });
+      registrations[name] = {
+        callbackId,
+        name,
+        type: def.type
+      };
+    }
+  }
+  return registrations;
+}
+async function serializeRequestWithStreaming(state, request) {
+  const headers = [];
+  request.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  let body = null;
+  let bodyStreamId;
+  let bodyStream;
+  if (request.body) {
+    const contentLength = request.headers.get("content-length");
+    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+    if (knownSize !== null && knownSize > import_protocol.STREAM_THRESHOLD) {
+      bodyStreamId = state.nextStreamId++;
+      bodyStream = request.body;
+    } else {
+      const clonedRequest = request.clone();
+      try {
+        body = new Uint8Array(await request.arrayBuffer());
+        if (body.length > import_protocol.STREAM_THRESHOLD) {
+          bodyStreamId = state.nextStreamId++;
+          bodyStream = clonedRequest.body;
+          body = null;
+        }
+      } catch {
+        bodyStreamId = state.nextStreamId++;
+        bodyStream = clonedRequest.body;
+      }
+    }
+  }
+  const result = {
+    method: request.method,
+    url: request.url,
+    headers,
+    body,
+    signalAborted: request.signal?.aborted ?? false
+  };
+  if (bodyStreamId !== undefined) {
+    result.bodyStreamId = bodyStreamId;
+    result.bodyStream = bodyStream;
+  }
+  return result;
+}
+function waitForUploadCredit(session) {
+  return new Promise((resolve) => {
+    session.creditResolver = resolve;
+  });
+}
+async function sendBodyStream(state, streamId, body) {
+  const session = {
+    streamId,
+    requestId: 0,
+    state: "active",
+    bytesTransferred: 0,
+    credit: 0
+  };
+  state.uploadStreams.set(streamId, session);
+  const reader = body.getReader();
+  try {
+    while (true) {
+      if (session.state !== "active") {
+        throw new Error("Stream cancelled");
+      }
+      while (session.credit < import_protocol.STREAM_CHUNK_SIZE && session.state === "active") {
+        await waitForUploadCredit(session);
+      }
+      if (session.state !== "active") {
+        throw new Error("Stream cancelled");
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        sendMessage(state.socket, {
+          type: import_protocol.MessageType.STREAM_CLOSE,
+          streamId
+        });
+        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);
+        sendMessage(state.socket, {
+          type: import_protocol.MessageType.STREAM_PUSH,
+          streamId,
+          chunk
+        });
+        session.credit -= chunk.length;
+        session.bytesTransferred += chunk.length;
+      }
+    }
+  } catch (err) {
+    sendMessage(state.socket, {
+      type: import_protocol.MessageType.STREAM_ERROR,
+      streamId,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    reader.releaseLock();
+    state.uploadStreams.delete(streamId);
+  }
+}
+function handleIsolateEvent(message, state) {
+  switch (message.event) {
+    case import_protocol.IsolateEvents.WS_COMMAND: {
+      const payload = message.payload;
+      const callbacks = isolateWsCallbacks.get(message.isolateId);
+      if (callbacks) {
+        let data;
+        if (payload.data instanceof Uint8Array) {
+          data = payload.data.buffer.slice(payload.data.byteOffset, payload.data.byteOffset + payload.data.byteLength);
+        } else {
+          data = payload.data;
+        }
+        const cmd = {
+          type: payload.type,
+          connectionId: payload.connectionId,
+          data,
+          code: payload.code,
+          reason: payload.reason
+        };
+        for (const cb of callbacks) {
+          cb(cmd);
+        }
+      }
+      break;
+    }
+    case import_protocol.IsolateEvents.WS_CLIENT_CONNECT: {
+      const payload = message.payload;
+      handleClientWsConnect(message.isolateId, payload, state);
+      break;
+    }
+    case import_protocol.IsolateEvents.WS_CLIENT_SEND: {
+      const payload = message.payload;
+      handleClientWsSend(message.isolateId, payload, state);
+      break;
+    }
+    case import_protocol.IsolateEvents.WS_CLIENT_CLOSE: {
+      const payload = message.payload;
+      handleClientWsClose(message.isolateId, payload, state);
+      break;
+    }
+    default: {
+      const listeners = isolateEventListeners.get(message.isolateId);
+      if (listeners) {
+        const eventListeners = listeners.get(message.event);
+        if (eventListeners) {
+          for (const cb of eventListeners) {
+            cb(message.payload);
+          }
+        }
+      }
+      break;
+    }
+  }
+}
+function handleClientWsConnect(isolateId, payload, state) {
+  const { socketId, url, protocols } = payload;
+  let sockets = isolateClientWebSockets.get(isolateId);
+  if (!sockets) {
+    sockets = new Map;
+    isolateClientWebSockets.set(isolateId, sockets);
+  }
+  const setupWebSocket = (ws) => {
+    sockets.set(socketId, ws);
+    ws.onopen = () => {
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event: import_protocol.ClientEvents.WS_CLIENT_OPENED,
+        payload: { socketId, protocol: ws.protocol || "", extensions: ws.extensions || "" }
+      });
+    };
+    ws.onmessage = (event) => {
+      let data;
+      if (typeof event.data === "string") {
+        data = event.data;
+      } else if (event.data instanceof ArrayBuffer) {
+        data = new Uint8Array(event.data);
+      } else if (event.data instanceof Blob) {
+        event.data.arrayBuffer().then((buffer) => {
+          sendMessage(state.socket, {
+            type: import_protocol.MessageType.CLIENT_EVENT,
+            isolateId,
+            event: import_protocol.ClientEvents.WS_CLIENT_MESSAGE,
+            payload: { socketId, data: new Uint8Array(buffer) }
+          });
+        });
+        return;
+      } else {
+        data = String(event.data);
+      }
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event: import_protocol.ClientEvents.WS_CLIENT_MESSAGE,
+        payload: { socketId, data }
+      });
+    };
+    ws.onerror = () => {
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event: import_protocol.ClientEvents.WS_CLIENT_ERROR,
+        payload: { socketId }
+      });
+    };
+    ws.onclose = (event) => {
+      sendMessage(state.socket, {
+        type: import_protocol.MessageType.CLIENT_EVENT,
+        isolateId,
+        event: import_protocol.ClientEvents.WS_CLIENT_CLOSED,
+        payload: { socketId, code: event.code, reason: event.reason, wasClean: event.wasClean }
+      });
+      sockets?.delete(socketId);
+      if (sockets?.size === 0) {
+        isolateClientWebSockets.delete(isolateId);
+      }
+    };
+  };
+  const sendConnectionFailed = (reason) => {
+    sendMessage(state.socket, {
+      type: import_protocol.MessageType.CLIENT_EVENT,
+      isolateId,
+      event: import_protocol.ClientEvents.WS_CLIENT_ERROR,
+      payload: { socketId }
+    });
+    sendMessage(state.socket, {
+      type: import_protocol.MessageType.CLIENT_EVENT,
+      isolateId,
+      event: import_protocol.ClientEvents.WS_CLIENT_CLOSED,
+      payload: { socketId, code: 1006, reason, wasClean: false }
+    });
+  };
+  const callback = isolateWebSocketCallbacks.get(isolateId);
+  if (callback) {
+    try {
+      const result = callback(url, protocols || []);
+      if (result instanceof Promise) {
+        result.then((ws) => {
+          if (ws === null) {
+            sendConnectionFailed("Connection blocked");
+          } else {
+            setupWebSocket(ws);
+          }
+        }).catch(() => {
+          sendConnectionFailed("Callback error");
+        });
+      } else if (result === null) {
+        sendConnectionFailed("Connection blocked");
+      } else {
+        setupWebSocket(result);
+      }
+    } catch {
+      sendConnectionFailed("Callback error");
+    }
+  } else {
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      setupWebSocket(ws);
+    } catch {
+      sendConnectionFailed("Connection failed");
+    }
+  }
+}
+function handleClientWsSend(isolateId, payload, state) {
+  const { socketId, data } = payload;
+  const sockets = isolateClientWebSockets.get(isolateId);
+  const ws = sockets?.get(socketId);
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    return;
+  }
+  if (typeof data === "string" && data.startsWith("__BINARY__")) {
+    const base64 = data.slice(10);
+    const binary = Buffer.from(base64, "base64");
+    ws.send(binary);
+  } else if (data instanceof Uint8Array) {
+    ws.send(Buffer.from(data));
+  } else {
+    ws.send(data);
+  }
+}
+function handleClientWsClose(isolateId, payload, state) {
+  const { socketId, code, reason } = payload;
+  const sockets = isolateClientWebSockets.get(isolateId);
+  const ws = sockets?.get(socketId);
+  if (!ws) {
+    return;
+  }
+  if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+    ws.close(code ?? 1000, reason ?? "");
+  }
+}
+
+//# debugId=7D1BE4A52F267ED264756E2164756E21