@volter/browser-substrate 0.1.118 → 0.1.120

package/catalog/published/v1/artifacts/sha256/1d9fc30121217ec1c2161e79c3df3e27047a786b8eb33ee6a218a887d794fa88

@@ -0,0 +1,4141 @@
+// packages/cdp/dist/chromium-face.js
+var encoder = new TextEncoder();
+function chromiumFaceRunner(attachClient) {
+  return async (argv, options) => {
+    const name = argv[0]?.slice(argv[0].lastIndexOf("/") + 1) ?? "chrome";
+    if (!argv.includes("--remote-debugging-pipe")) {
+      return { stdout: "", stderr: `${name}: the tab's Chromium is driven over --remote-debugging-pipe only
+`, exitCode: 1 };
+    }
+    const commands = options.descriptors?.[3];
+    const replies = options.descriptors?.[4];
+    if (!commands || !replies) {
+      return { stdout: "", stderr: `${name}: --remote-debugging-pipe needs pipes on fds 3 and 4
+`, exitCode: 1 };
+    }
+    const messageListeners = [];
+    const closeListeners = [];
+    let open = true;
+    let finished;
+    const done = new Promise((resolve) => {
+      finished = resolve;
+    });
+    const end = () => {
+      if (!open)
+        return;
+      open = false;
+      replies.end();
+      for (const listener of closeListeners)
+        listener();
+      finished();
+    };
+    const peer = {
+      get readyState() {
+        return open ? 1 : 3;
+      },
+      send: (data) => {
+        if (open)
+          replies.write(encoder.encode(`${data}\0`));
+      },
+      close: () => end(),
+      on: ((event, listener) => {
+        if (event === "message")
+          messageListeners.push(listener);
+        else
+          closeListeners.push(listener);
+      })
+    };
+    options.signal?.addEventListener("abort", end, { once: true });
+    attachClient(peer);
+    void (async () => {
+      const decoder3 = new TextDecoder();
+      let buffered = "";
+      for await (const chunk of commands.input) {
+        buffered += decoder3.decode(chunk, { stream: true });
+        for (let boundary = buffered.indexOf("\0"); boundary >= 0; boundary = buffered.indexOf("\0")) {
+          const message = buffered.slice(0, boundary);
+          buffered = buffered.slice(boundary + 1);
+          const closing = browserClose(message);
+          if (closing !== void 0) {
+            peer.send(JSON.stringify({ id: closing, result: {} }));
+            end();
+            return;
+          }
+          for (const listener of messageListeners)
+            listener(message);
+          if (!open)
+            return;
+        }
+      }
+      end();
+    })().catch(end);
+    await done;
+    return { stdout: "", stderr: "", exitCode: 0 };
+  };
+}
+function browserClose(message) {
+  try {
+    const parsed = JSON.parse(message);
+    return parsed.method === "Browser.close" && parsed.sessionId === void 0 && typeof parsed.id === "number" ? parsed.id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function playwrightChromiumRevisions(filesystem, roots) {
+  const revisions = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const path = `${root.replace(/\/$/u, "")}/node_modules/playwright-core/browsers.json`;
+    if (!filesystem.existsSync(path))
+      continue;
+    try {
+      const pinned = JSON.parse(await filesystem.readFile(path, "utf8"));
+      for (const entry of pinned.browsers ?? []) {
+        if ((entry.name === "chromium" || entry.name === "chromium-headless-shell") && typeof entry.revision === "string")
+          revisions.add(entry.revision);
+      }
+    } catch {
+    }
+  }
+  return [...revisions];
+}
+async function placeChromiumFace(filesystem, cacheDirectory, revisions, baseline) {
+  for (const revision of revisions) {
+    if (!baseline.revisions.includes(revision))
+      throw new Error(`Playwright revision ${revision} has no qualified Chromium protocol face. Prepare its baseline on a host.`);
+    for (const placement of baseline.placements) {
+      const root = `${cacheDirectory}/${placement.directory}-${revision}`;
+      const executable = `${root}/${placement.executable}`;
+      filesystem.mkdirSync(executable.slice(0, executable.lastIndexOf("/")), { recursive: true });
+      const name = placement.executable.slice(placement.executable.lastIndexOf("/") + 1);
+      const stub = `#!/bin/sh
+# ${name}: runtime-registered program
+`;
+      let current;
+      try {
+        current = filesystem.existsSync(executable) ? await filesystem.readFile(executable, "utf8") : void 0;
+      } catch {
+        current = void 0;
+      }
+      if (current !== stub) {
+        filesystem.writeFileSync(executable, stub);
+        filesystem.chmodSync?.(executable, 493);
+      }
+      for (const marker of ["INSTALLATION_COMPLETE", "DEPENDENCIES_VALIDATED"]) {
+        if (!filesystem.existsSync(`${root}/${marker}`))
+          filesystem.writeFileSync(`${root}/${marker}`, "");
+      }
+    }
+  }
+}
+
+// node_modules/@volter/almostcdp/dist/browser-pages.js
+var BrowserPages = class {
+  host;
+  hooks;
+  timeoutMs;
+  pages = /* @__PURE__ */ new Map();
+  stopped = false;
+  retired = /* @__PURE__ */ new Set();
+  constructor(host, hooks, timeoutMs) {
+    this.host = host;
+    this.hooks = hooks;
+    this.timeoutMs = timeoutMs;
+  }
+  context(id) {
+    return this.pages.get(id)?.contextId;
+  }
+  opener(id) {
+    return this.pages.get(id)?.openerId;
+  }
+  openerMark(id) {
+    return this.pages.get(id)?.openerMark;
+  }
+  ownMark(id) {
+    return this.pages.get(id)?.ownMark;
+  }
+  owner(id) {
+    return this.pages.get(id)?.owner;
+  }
+  acceptsSurface(id) {
+    if (this.retired.has(id))
+      return false;
+    const page = this.pages.get(id);
+    return !page || !page.controller.signal.aborted && !page.closing && !this.stopped && (!page.contextId || this.hooks.contextExists(page.contextId));
+  }
+  async create(owner, params, openerId, openerMark, ownMark) {
+    if (this.stopped)
+      throw new Error("Browser host is closing");
+    for (const key of Object.keys(params))
+      if (!["url", "browserContextId"].includes(key))
+        throw new Error(`Unsupported page option: ${key}`);
+    if (typeof params.url !== "string")
+      throw new Error("url must be a string");
+    if (params.browserContextId !== void 0 && typeof params.browserContextId !== "string")
+      throw new Error("browserContextId must be a string");
+    const contextId = params.browserContextId;
+    if (contextId !== void 0 && !this.hooks.contextExists(contextId))
+      throw new Error("No browser context with given id");
+    const page = { id: crypto.randomUUID().replaceAll("-", ""), contextId, ...openerId ? { openerId } : {}, ...openerMark ? { openerMark } : {}, ...ownMark ? { ownMark } : {}, owner, controller: new AbortController(), ready: false, settled: false };
+    this.pages.set(page.id, page);
+    const timer = setTimeout(() => page.controller.abort(new Error("Page creation timed out")), this.timeoutMs);
+    let onAbort = () => {
+    };
+    const aborted = new Promise((_, reject) => {
+      onAbort = () => {
+        this.hooks.disconnectSurface(page.id);
+        reject(page.controller.signal.reason);
+      };
+      page.controller.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    const completed = Promise.resolve().then(() => this.host.createPage({
+      id: page.id,
+      url: params.url,
+      ...contextId !== void 0 ? { browserContextId: contextId } : {}
+    }, page.controller.signal)).then(async () => {
+      page.settled = true;
+      if (!this.acceptsSurface(page.id) || !this.hooks.surfaceExists(page.id)) {
+        const error = page.controller.signal.reason ?? new Error("Host did not register a live page surface");
+        page.controller.abort(error);
+        await this.closeEntry(page);
+        throw error;
+      }
+      page.ready = true;
+      return page.id;
+    }, async (error) => {
+      page.settled = true;
+      page.controller.abort(error);
+      await this.closeEntry(page);
+      throw error;
+    });
+    try {
+      return await Promise.race([completed, aborted]);
+    } finally {
+      clearTimeout(timer);
+      page.controller.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  closeEntry(page) {
+    if (!page.closing)
+      page.closing = Promise.resolve().then(() => this.host.closePage(page.id)).then(() => {
+        this.hooks.disconnectSurface(page.id);
+        this.retired.add(page.id);
+        this.pages.delete(page.id);
+      }, (error) => {
+        page.closing = void 0;
+        throw error;
+      });
+    return page.closing;
+  }
+  async closeTarget(id) {
+    const page = this.pages.get(id);
+    if (!page?.ready || !this.hooks.surfaceExists(id))
+      throw new Error("No managed page with given id");
+    await this.closeEntry(page);
+  }
+  disconnect(owner) {
+    for (const page of this.pages.values())
+      if (page.owner === owner && !page.ready)
+        page.controller.abort(new Error("Page creator disconnected"));
+  }
+  async disposeContext(id) {
+    const closing = [];
+    for (const page of this.pages.values())
+      if (page.contextId === id) {
+        if (!page.ready)
+          page.controller.abort(new Error("Browser context disposed"));
+        if (page.settled)
+          closing.push(this.closeEntry(page));
+      }
+    await Promise.all(closing);
+  }
+  async close() {
+    this.stopped = true;
+    const closing = [];
+    for (const page of this.pages.values()) {
+      if (!page.ready)
+        page.controller.abort(new Error("Browser host is closing"));
+      if (page.settled)
+        closing.push(this.closeEntry(page));
+    }
+    await Promise.all(closing);
+  }
+};
+
+// node_modules/@volter/almostcdp/dist/browser-contexts.js
+var BrowserContexts = class {
+  host;
+  timeoutMs;
+  contexts = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(host, timeoutMs) {
+    this.host = host;
+    this.timeoutMs = timeoutMs;
+  }
+  ids() {
+    return [...this.contexts.values()].filter((c) => c.ready && !c.disposal).map((c) => c.id);
+  }
+  async create(owner, params) {
+    if (this.closed)
+      throw new Error("Browser host is closing");
+    const supported = /* @__PURE__ */ new Set(["disposeOnDetach", "proxyServer", "proxyBypassList", "originsWithUniversalNetworkAccess"]);
+    for (const key of Object.keys(params))
+      if (!supported.has(key))
+        throw new Error(`Unsupported context option: ${key}`);
+    if (params.disposeOnDetach !== void 0 && typeof params.disposeOnDetach !== "boolean")
+      throw new Error("disposeOnDetach must be boolean");
+    for (const key of ["proxyServer", "proxyBypassList"])
+      if (params[key] !== void 0 && typeof params[key] !== "string")
+        throw new Error(`${key} must be a string`);
+    const origins = params.originsWithUniversalNetworkAccess;
+    if (origins !== void 0 && (!Array.isArray(origins) || !origins.every((value) => typeof value === "string")))
+      throw new Error("originsWithUniversalNetworkAccess must be a string array");
+    const c = { id: crypto.randomUUID().replaceAll("-", ""), owner, disposeOnDetach: params.disposeOnDetach === true, controller: new AbortController(), ready: false, settled: false };
+    this.contexts.set(c.id, c);
+    const timer = setTimeout(() => c.controller.abort(new Error("Context creation timed out")), this.timeoutMs);
+    const creation = Promise.resolve().then(() => this.host.createContext({
+      id: c.id,
+      ...params.proxyServer !== void 0 ? { proxyServer: params.proxyServer } : {},
+      ...params.proxyBypassList !== void 0 ? { proxyBypassList: params.proxyBypassList } : {},
+      ...origins !== void 0 ? { originsWithUniversalNetworkAccess: origins } : {}
+    }, c.controller.signal));
+    const completed = creation.then(async () => {
+      c.settled = true;
+      if (c.controller.signal.aborted || this.closed) {
+        await this.disposeEntry(c);
+        throw c.controller.signal.reason ?? new Error("Browser host is closing");
+      }
+      c.ready = true;
+      return c.id;
+    }, async (error) => {
+      c.settled = true;
+      await this.disposeEntry(c);
+      throw error;
+    });
+    let onAbort = () => {
+    };
+    const aborted = new Promise((_, reject) => {
+      onAbort = () => reject(c.controller.signal.reason);
+      c.controller.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([completed, aborted]);
+    } finally {
+      clearTimeout(timer);
+      c.controller.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  disposeEntry(c) {
+    if (!c.disposal) {
+      c.disposal = Promise.resolve().then(() => this.host.disposeContext(c.id)).then(() => {
+        this.contexts.delete(c.id);
+      }, (error) => {
+        c.disposal = void 0;
+        throw error;
+      });
+    }
+    return c.disposal;
+  }
+  async dispose(id) {
+    const c = this.contexts.get(id);
+    if (!c?.ready)
+      throw new Error("No browser context with given id");
+    await this.disposeEntry(c);
+  }
+  async disconnect(owner) {
+    const disposals = [];
+    for (const c of this.contexts.values()) {
+      if (c.owner !== owner)
+        continue;
+      if (!c.ready)
+        c.controller.abort(new Error("Context creator disconnected"));
+      else if (c.disposeOnDetach)
+        disposals.push(this.disposeEntry(c));
+    }
+    await Promise.all(disposals);
+  }
+  async close() {
+    this.closed = true;
+    for (const c of this.contexts.values())
+      if (!c.ready)
+        c.controller.abort(new Error("Browser host is closing"));
+    await Promise.all([...this.contexts.values()].filter((c) => c.settled).map((c) => this.disposeEntry(c)));
+  }
+};
+
+// node_modules/@volter/almostcdp/dist/protocol.js
+var unsupported = (method) => ({
+  code: -32601,
+  message: `'${method}' wasn't found`,
+  data: "AlmostCDP does not implement this command for the connected surface"
+});
+
+// node_modules/@volter/almostcdp/dist/surface-module.js
+var base64ToBytes = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++)
+    bytes[index] = binary.charCodeAt(index);
+  return bytes;
+};
+var bytesToBase64 = (bytes) => {
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+  }
+  return btoa(binary);
+};
+
+// node_modules/@volter/almostcdp/dist/cookies.js
+var FAN_OUT_PARAM = "almostcdpFanOut";
+
+// node_modules/@volter/almostcdp/dist/downloads.js
+var DOWNLOAD_POLICY_PARAM = "almostcdpDownloadPolicy";
+
+// node_modules/@volter/almostcdp/dist/file-chooser.js
+var FILE_PAYLOADS_PARAM = "almostcdpFiles";
+
+// node_modules/@volter/almostcdp/dist/support.js
+var SUPPORT_MANIFEST = {
+  adapters: {
+    accessibility: "optional",
+    capture: "optional",
+    browserContexts: "optional-host-owned-storage-isolation",
+    browserPages: "optional-host-owned-page-lifecycle",
+    rrwebCast: "optional",
+    surface: "same-origin DOM"
+  },
+  commands: {
+    hostContext: ["Target.createBrowserContext", "Target.disposeBrowserContext"],
+    hostPage: ["Target.createTarget", "Target.closeTarget"],
+    browser: [
+      "Browser.cancelDownload",
+      "Browser.getBrowserCommandLine",
+      "Browser.getVersion",
+      "Browser.setDownloadBehavior",
+      "Browser.grantPermissions",
+      "Browser.resetPermissions",
+      "Storage.clearCookies",
+      "Storage.getCookies",
+      "Storage.setCookies",
+      "Target.activateTarget",
+      "Target.attachToTarget",
+      "Target.attachToBrowserTarget",
+      "Target.detachFromTarget",
+      "Target.getTargetInfo",
+      "Target.getBrowserContexts",
+      "Target.getTargets",
+      "Target.setAutoAttach",
+      "Target.setDiscoverTargets"
+    ],
+    surface: [
+      "Accessibility.disable",
+      "Browser.cancelDownload",
+      "Browser.grantPermissions",
+      "Browser.resetPermissions",
+      "Browser.setDownloadBehavior",
+      "Accessibility.enable",
+      "Accessibility.getChildAXNodes",
+      "Accessibility.getFullAXTree",
+      "Accessibility.getPartialAXTree",
+      "Accessibility.getRootAXNode",
+      "Accessibility.queryAXTree",
+      "DOM.describeNode",
+      "DOM.disable",
+      "DOM.enable",
+      "DOM.focus",
+      "DOM.getBoxModel",
+      "DOM.getContentQuads",
+      "DOM.getDocument",
+      "DOM.querySelector",
+      "DOM.querySelectorAll",
+      "DOM.requestNode",
+      "DOM.requestChildNodes",
+      "DOM.resolveNode",
+      "DOM.scrollIntoViewIfNeeded",
+      "DOM.setFileInputFiles",
+      "Emulation.clearDeviceMetricsOverride",
+      "Emulation.clearGeolocationOverride",
+      "Audits.disable",
+      "Audits.enable",
+      "Performance.disable",
+      "Performance.enable",
+      "Performance.getMetrics",
+      "Emulation.setDeviceMetricsOverride",
+      "Emulation.setEmulatedMedia",
+      "Emulation.setFocusEmulationEnabled",
+      "Emulation.setGeolocationOverride",
+      "Emulation.setLocaleOverride",
+      "Emulation.setTouchEmulationEnabled",
+      "Emulation.setUserAgentOverride",
+      "Fetch.continueRequest",
+      "Fetch.disable",
+      "Fetch.enable",
+      "Fetch.failRequest",
+      "Fetch.fulfillRequest",
+      "Input.dispatchDragEvent",
+      "Input.dispatchKeyEvent",
+      "Input.dispatchMouseEvent",
+      "Input.dispatchTouchEvent",
+      "Input.emulateTouchFromMouseEvent",
+      "Input.imeSetComposition",
+      "Input.insertText",
+      "Input.setInterceptDrags",
+      "Log.disable",
+      "Log.enable",
+      "Network.disable",
+      "Network.enable",
+      "Network.getResponseBody",
+      "Network.setCacheDisabled",
+      "Network.setExtraHTTPHeaders",
+      "Page.addScriptToEvaluateOnNewDocument",
+      "Page.bringToFront",
+      "Page.captureScreenshot",
+      "Page.close",
+      "Page.createIsolatedWorld",
+      "Page.deleteCookie",
+      "Page.disable",
+      "Page.enable",
+      "Page.getFrameTree",
+      "Page.handleJavaScriptDialog",
+      "Page.getLayoutMetrics",
+      "Page.getNavigationHistory",
+      "Page.getResourceTree",
+      "Page.navigate",
+      "Page.navigateToHistoryEntry",
+      "Page.reload",
+      "Page.removeScriptToEvaluateOnNewDocument",
+      "Page.setFontFamilies",
+      "Page.setInterceptFileChooserDialog",
+      "Page.screencastFrameAck",
+      "Page.setLifecycleEventsEnabled",
+      "Page.setTouchEmulationEnabled",
+      "Page.startScreencast",
+      "Page.stopScreencast",
+      "Runtime.addBinding",
+      "Runtime.callFunctionOn",
+      "Runtime.disable",
+      "Runtime.enable",
+      "Runtime.evaluate",
+      "Runtime.getProperties",
+      "Runtime.releaseObject",
+      "Runtime.releaseObjectGroup",
+      "Runtime.runIfWaitingForDebugger",
+      "Schema.getDomains",
+      "Storage.clearCookies",
+      "Storage.getCookies",
+      "Storage.setCookies",
+      "Target.activateTarget",
+      "Target.setAutoAttach"
+    ],
+    /** Answered with a named protocol error: the surface cannot perform them. */
+    refused: [
+      "Browser.getWindowForTarget",
+      "Emulation.setDefaultBackgroundColorOverride",
+      "Emulation.setOrientationOverride",
+      "Emulation.setScriptExecutionDisabled",
+      "Emulation.setTimezoneOverride",
+      "Fetch.continueWithAuth",
+      "Network.clearBrowserCache",
+      "Network.emulateNetworkConditions",
+      "Network.loadNetworkResource",
+      "Network.setBypassServiceWorker",
+      "Page.setBypassCSP",
+      "Security.setIgnoreCertificateErrors"
+    ]
+  },
+  /**
+   * Refused by name because no backend exists (tracing, profiling, debugging,
+   * CSS inspection, streams, printing, browser windows, child frames). The
+   * listed commands are the ones the pinned Playwright sends only on request.
+   */
+  unimplemented: {
+    domains: ["CSS", "Debugger", "HeapProfiler", "IO", "Profiler", "Tracing"],
+    commands: [
+      "Browser.close",
+      "Browser.getWindowBounds",
+      "Browser.setDockTile",
+      "Browser.setWindowBounds",
+      "Console.enable",
+      "DOM.getFrameOwner",
+      "Page.printToPDF",
+      "Target.sendMessageToTarget"
+    ]
+  },
+  fidelity: {
+    dialogs: "reported-and-dismissed-synchronously-while-Page-is-observed; accept refused",
+    downloads: "anchor downloads (a[download], blob:, data:) intercepted by the surface and written through the host; downloads the host browser starts from an attachment navigation are its own",
+    capture: "adapter-declared",
+    deviceScaleFactor: "js-visible-only",
+    history: "frame-scoped via the Navigation API; without it, agent-observed entries and traversal refused",
+    pageClose: "host-hook-required",
+    urls: "host-mapped; page script sees the frame's real location",
+    userAgent: "js-visible-only; HTTP headers unchanged; navigator.platform only from the platform parameter",
+    locale: "js-visible-only; Intl constructors, toLocale*String and navigator.language(s)",
+    geolocation: "js-visible-only; navigator.geolocation answers only while geolocation is granted",
+    permissions: "js-visible-only; navigator.permissions.query and Notification.permission; host prompts unchanged",
+    touch: "js-visible-only; navigator.maxTouchPoints and ontouchstart",
+    realmOverrides: "installed when a document finishes loading; scripts that run earlier see host values",
+    cookies: "script-visible-only; HttpOnly cookies unreadable and unsettable; each surface reaches its own host and path",
+    fileChooser: "click-and-showPicker-interception; files assigned only through a host file adapter",
+    fontFamilies: "standard-applied; generic families resolved by host browser; forScripts ignored",
+    screenSize: "js-visible-only",
+    viewport: "frame-element-resized; a top-level surface accepts only its current size",
+    input: "synthetic-isTrusted-false",
+    dragAndDrop: "synthetic-DataTransfer; draggable-element drags only (no text-selection or file drags)",
+    keyboardEditing: "text-controls-code-point-movement-and-deletion; no-platform-word-or-grapheme-segmentation",
+    legacyTouchEmulation: "mouse-events-only",
+    wheel: "synthetic-cancelable-event-and-scrollable-ancestor-default-action",
+    network: "fetch-and-xhr-observation",
+    interception: "fetch-and-xhr-only; synchronous XHR and response-stage interception unavailable; authentication challenges stay with the host browser",
+    responseBodies: "fetch-and-xhr; 8-MiB-LRU; json/document XHR bodies unavailable",
+    cacheDisabled: "fetch-requests-use-no-store; XHR, navigation and subresources keep the HTTP cache",
+    rrweb: "side-channel"
+  },
+  protocol: {
+    devtoolsProtocolPackage: "0.0.1702366",
+    protocolVersion: "1.3"
+  },
+  version: 1
+};
+
+// node_modules/@volter/almostcdp/dist/unavailable.js
+var UNAVAILABLE_DOMAINS = {
+  CSS: "no style-engine inspection backend; stylesheets and rule usage belong to the host browser",
+  Debugger: "no script debugger backend; scripts run in the host browser's engine",
+  HeapProfiler: "no heap inspection or garbage-collection backend",
+  IO: "no protocol stream backend; nothing produces stream handles",
+  Profiler: "no CPU profiling or coverage backend",
+  Tracing: "no tracing backend"
+};
+var UNAVAILABLE_COMMANDS = {
+  "Browser.cancelDownload": "downloads are not modelled without a host download adapter",
+  "Browser.close": "the browser belongs to the embedding host",
+  "Browser.getWindowBounds": "a surface has no browser window",
+  "Browser.getWindowForTarget": "a surface has no browser window",
+  "Browser.setDockTile": "a surface has no browser window",
+  "Browser.setWindowBounds": "a surface has no browser window",
+  "Console.enable": "console messages are reported through Runtime and Log",
+  "DOM.getFrameOwner": "child frames are not modelled",
+  "Emulation.setDefaultBackgroundColorOverride": "the page background is painted by the host browser's compositor",
+  "Emulation.setScriptExecutionDisabled": "script execution is controlled by the host browser",
+  "Emulation.setTimezoneOverride": "the time zone of Date and Intl is fixed by the host browser's realm",
+  "Network.clearBrowserCache": "the HTTP cache belongs to the host browser",
+  "Network.emulateNetworkConditions": "network conditions are applied by the host browser's network stack",
+  "Network.loadNetworkResource": "resources outside the page's own fetch are loaded by the host browser",
+  "Network.setBypassServiceWorker": "service-worker routing belongs to the host browser",
+  "Page.printToPDF": "no print or PDF backend",
+  "Page.setBypassCSP": "Content-Security-Policy is enforced by the host browser",
+  "Security.setIgnoreCertificateErrors": "certificate validation belongs to the host browser",
+  "Target.sendMessageToTarget": "sessions are flattened; nested message routing is not modelled"
+};
+var unavailableCommand = (method) => {
+  const why = UNAVAILABLE_COMMANDS[method] ?? UNAVAILABLE_DOMAINS[method.split(".")[0]];
+  return why === void 0 ? void 0 : { code: -32e3, message: `${method} is unavailable on a DOM surface: ${why}` };
+};
+
+// node_modules/@volter/almostcdp/dist/discovery.js
+function discoveryDocument(source, address, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname;
+  const wsOrigin = /^wss?:\/\//u.test(address) ? address : `ws://${address}`;
+  const hostAddress = wsOrigin.replace(/^wss?:\/\//u, "");
+  if (path === "/json/version") {
+    return {
+      status: 200,
+      body: {
+        "Browser": "AlmostCDP/0.1.0",
+        "Protocol-Version": "1.3",
+        "User-Agent": "AlmostCDP/0.1.0",
+        "V8-Version": "0",
+        "WebKit-Version": "0",
+        "webSocketDebuggerUrl": `${wsOrigin}/devtools/browser/${source.browserId}`
+      }
+    };
+  }
+  if (path === "/json" || path === "/json/list") {
+    return {
+      status: 200,
+      body: source.targets().map((surface) => ({
+        description: "",
+        devtoolsFrontendUrl: `/devtools/inspector.html?${wsOrigin.startsWith("wss:") ? "wss" : "ws"}=${hostAddress}/devtools/page/${surface.id}`,
+        id: surface.id,
+        title: surface.title,
+        type: surface.type,
+        url: surface.url,
+        webSocketDebuggerUrl: `${wsOrigin}/devtools/page/${surface.id}`
+      }))
+    };
+  }
+  if (path === "/health")
+    return { status: 200, body: { ok: true, surfaces: source.targets().length } };
+  if (path === "/compatibility")
+    return { status: 200, body: source.compatibility() };
+  return { status: 404, body: { error: "not found" } };
+}
+
+// node_modules/@volter/almostcdp/dist/dispatcher.js
+var SubsurfacePeer = class {
+  deliver;
+  readyState = 1;
+  listeners = { message: [], close: [] };
+  constructor(deliver) {
+    this.deliver = deliver;
+  }
+  send(data) {
+    if (this.readyState === 1)
+      this.deliver({ data });
+  }
+  close() {
+    if (this.readyState !== 1)
+      return;
+    this.deliver({ close: true });
+    this.closed();
+  }
+  on(event, listener) {
+    this.listeners[event].push(listener);
+  }
+  received(data) {
+    if (this.readyState === 1)
+      for (const listener of this.listeners.message)
+        listener(data);
+  }
+  closed() {
+    if (this.readyState === 3)
+      return;
+    this.readyState = 3;
+    for (const listener of this.listeners.close)
+      listener();
+  }
+};
+var stagedSequence = 0;
+var json = (ws, value) => {
+  if ((ws.bufferedAmount ?? 0) > 8 * 1024 * 1024) {
+    ws.close(1013, "Consumer too slow; reconnect for a fresh snapshot");
+    return;
+  }
+  if (ws.readyState === 1)
+    ws.send(JSON.stringify(value));
+};
+var targetInfo = (surface) => ({
+  attached: false,
+  browserContextId: surface.contextId ?? "default",
+  canAccessOpener: false,
+  targetId: surface.description.id,
+  title: surface.description.title,
+  type: surface.description.type,
+  url: surface.description.url
+});
+function createDispatcher(options) {
+  const { browserId, surfaceToken } = options;
+  const surfaces = /* @__PURE__ */ new Map();
+  const subsurfaceParents = /* @__PURE__ */ new WeakMap();
+  const autoAttaches = (client, parent, surface) => {
+    if (!parent)
+      return surface.parentId === void 0;
+    return surface.parentId !== void 0 && client.sessions.get(parent) === surface.parentId;
+  };
+  const successions = /* @__PURE__ */ new Map();
+  const successionGraceMs = options.successionGraceMs ?? 15e3;
+  const contexts = options.contextHost ? new BrowserContexts({
+    createContext: (params, signal) => options.contextHost.createContext(params, signal),
+    disposeContext: async (id) => {
+      await pages?.disposeContext(id);
+      await options.contextHost.disposeContext(id);
+    }
+  }, options.commandTimeoutMs ?? 15e3) : void 0;
+  const pages = options.pageHost ? new BrowserPages(options.pageHost, {
+    contextExists: (id) => contexts?.ids().includes(id) ?? false,
+    surfaceExists: (id) => surfaces.get(id)?.ws.readyState === 1,
+    disconnectSurface: (id) => surfaces.get(id)?.ws.close(1001, "Managed page closed")
+  }, options.commandTimeoutMs ?? 15e3) : void 0;
+  const clients = /* @__PURE__ */ new Set();
+  const pageInfo = (surface) => {
+    const openerId = pages?.opener(surface.description.id);
+    return { ...targetInfo(surface), ...openerId ? { openerId, canAccessOpener: pages?.openerMark(surface.description.id) !== void 0 } : {} };
+  };
+  const castViewers = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const commandCounts = /* @__PURE__ */ new Map();
+  const screencastOwners = /* @__PURE__ */ new Map();
+  const contextGrants = /* @__PURE__ */ new Map();
+  const downloadPolicies = /* @__PURE__ */ new Map();
+  const downloadsInFlight = /* @__PURE__ */ new Map();
+  const policyCommand = (policy) => ({
+    id: 0,
+    method: "Browser.setDownloadBehavior",
+    params: { [DOWNLOAD_POLICY_PARAM]: true, behavior: policy.behavior }
+  });
+  let relaySequence = 0;
+  const sendResponse = (client, command, result = {}) => {
+    const response = { id: command.id, result };
+    if (command.sessionId)
+      response.sessionId = command.sessionId;
+    json(client.ws, response);
+  };
+  const sendError = (client, command, error = unsupported(command.method)) => {
+    const response = { error, id: command.id };
+    if (command.sessionId)
+      response.sessionId = command.sessionId;
+    json(client.ws, response);
+  };
+  const attach = (client, surface, parentSessionId) => {
+    const sessionId = globalThis.crypto.randomUUID().replaceAll("-", "");
+    client.sessions.set(sessionId, surface.description.id);
+    client.parents.set(sessionId, parentSessionId ?? "");
+    const event = {
+      method: "Target.attachedToTarget",
+      ...parentSessionId ? { sessionId: parentSessionId } : {},
+      params: {
+        sessionId,
+        targetInfo: { ...pageInfo(surface), attached: true },
+        waitingForDebugger: false
+      }
+    };
+    json(client.ws, event);
+    return sessionId;
+  };
+  const forward = (client, command, surface) => {
+    const files = command.params?.files;
+    if (command.method === "DOM.setFileInputFiles" && options.fileHost && Array.isArray(files) && files.length && command.params?.[FILE_PAYLOADS_PARAM] === void 0) {
+      const host = options.fileHost;
+      const token = `files-${++stagedSequence}`;
+      void (async () => {
+        const paths = [];
+        for (const named of files) {
+          const path = String(named);
+          const entries = await host.list?.(path);
+          if (!entries) {
+            paths.push({ path });
+            continue;
+          }
+          const base = path.replace(/[\\/]+$/u, "");
+          const folder = base.split(/[\\/]/u).pop() ?? base;
+          for (const entry of entries)
+            paths.push({ path: `${base}/${entry}`, relativePath: `${folder}/${entry}` });
+        }
+        for (const [index, { path, relativePath }] of paths.entries()) {
+          const file = await host.read(path);
+          json(surface.ws, {
+            type: "stage-file",
+            token,
+            index,
+            name: file.name ?? path.split(/[\\/]/u).pop() ?? path,
+            ...file.type ? { mimeType: file.type } : {},
+            ...file.lastModified !== void 0 ? { lastModified: file.lastModified } : {},
+            ...relativePath ? { relativePath } : {},
+            dataBase64: bytesToBase64(file.data)
+          });
+        }
+        return paths.length;
+      })().then((count) => forward(client, { ...command, params: { ...command.params, files: [], [FILE_PAYLOADS_PARAM]: { token, count } } }, surface), (error) => sendError(client, command, { code: -32e3, message: error instanceof Error ? error.message : String(error) }));
+      return;
+    }
+    const key = command.sessionId ?? "direct";
+    const domain = command.method.split(".")[0];
+    let settleSubscription;
+    if (command.method === `${domain}.enable` || command.method === `${domain}.disable`) {
+      const domains = client.subscriptionChanges.get(key) ?? /* @__PURE__ */ new Map();
+      client.subscriptionChanges.set(key, domains);
+      const state = domains.get(domain) ?? { enabled: client.subscriptions.get(key)?.has(domain) ?? false, changes: [] };
+      domains.set(domain, state);
+      const change = { enabled: command.method.endsWith(".enable") };
+      state.changes.push(change);
+      const update = () => {
+        let enabled = state.enabled;
+        for (const pending2 of state.changes)
+          if (pending2.accepted !== false)
+            enabled = pending2.enabled;
+        const subscriptions = client.subscriptions.get(key) ?? /* @__PURE__ */ new Set();
+        if (enabled)
+          subscriptions.add(domain);
+        else
+          subscriptions.delete(domain);
+        client.subscriptions.set(key, subscriptions);
+      };
+      update();
+      settleSubscription = (accepted) => {
+        if (client.subscriptionChanges.get(key)?.get(domain) !== state)
+          return;
+        change.accepted = accepted;
+        while (state.changes[0]?.accepted !== void 0) {
+          const completed = state.changes.shift();
+          if (completed.accepted)
+            state.enabled = completed.enabled;
+        }
+        update();
+        if (!state.changes.length) {
+          domains.delete(domain);
+          if (!domains.size)
+            client.subscriptionChanges.delete(key);
+        }
+      };
+    }
+    if (command.method === `${domain}.disable`) {
+      const stillObserved = [...clients].some((other) => [...other.subscriptions].some(([sessionId, domains]) => domains.has(domain) && (sessionId === "direct" ? other.directSurfaceId : other.sessions.get(sessionId)) === surface.description.id));
+      if (stillObserved && domain !== "Runtime" && domain !== "DOM" && domain !== "Fetch") {
+        settleSubscription?.(true);
+        sendResponse(client, command);
+        return;
+      }
+    }
+    let settleCapture;
+    if (command.method.startsWith("Page.") && ["Page.startScreencast", "Page.stopScreencast", "Page.screencastFrameAck"].includes(command.method)) {
+      const owner = screencastOwners.get(surface.description.id);
+      if (owner && (owner.client !== client || owner.sessionId !== command.sessionId)) {
+        sendError(client, command, { code: -32e3, message: "Screencast belongs to another session" });
+        return;
+      }
+      if (command.method === "Page.startScreencast") {
+        const claim = { client, sessionId: command.sessionId };
+        screencastOwners.set(surface.description.id, claim);
+        settleCapture = (accepted) => {
+          if (accepted || screencastOwners.get(surface.description.id) !== claim)
+            return;
+          screencastOwners.delete(surface.description.id);
+          json(surface.ws, { type: "command", relayId: `cleanup-${++relaySequence}`, message: { id: 0, method: "Page.stopScreencast" } });
+        };
+      }
+      if (command.method === "Page.stopScreencast")
+        settleCapture = (accepted) => {
+          if (accepted && screencastOwners.get(surface.description.id) === owner)
+            screencastOwners.delete(surface.description.id);
+        };
+    }
+    const relayId = `r${++relaySequence}`;
+    const timer = setTimeout(() => {
+      pending.delete(relayId);
+      settleSubscription?.(false);
+      settleCapture?.(false);
+      sendError(client, command, { code: -32e3, message: "Surface command timed out" });
+    }, options.commandTimeoutMs ?? 3e4);
+    pending.set(relayId, { client, command, surface, timer, settleSubscription, settleCapture });
+    const payload = {
+      message: { id: command.id, method: command.method, params: command.params, sessionId: `${client.id}:${key}` },
+      relayId,
+      type: "command"
+    };
+    json(surface.ws, payload);
+  };
+  const detach = (client, sessionId) => {
+    pages?.disconnect(`${client.id}:${sessionId}`);
+    void contexts?.disconnect(`${client.id}:${sessionId}`).catch(() => {
+    });
+    const targetId = client.sessions.get(sessionId);
+    const parent = client.parents.get(sessionId) ?? "";
+    for (const [child, owner] of [...client.parents])
+      if (owner === sessionId)
+        detach(client, child);
+    client.parents.delete(sessionId);
+    client.automaticSessions.delete(sessionId);
+    client.autoAttach.delete(sessionId);
+    client.discover.delete(sessionId);
+    client.sessions.delete(sessionId);
+    client.subscriptions.delete(sessionId);
+    client.subscriptionChanges.delete(sessionId);
+    client.browserSessions.delete(sessionId);
+    const surface = targetId ? surfaces.get(targetId) : void 0;
+    if (surface) {
+      json(surface.ws, { type: "session-closed", sessionId: `${client.id}:${sessionId}` });
+      const owner = screencastOwners.get(targetId);
+      if (owner?.client === client && owner.sessionId === sessionId) {
+        screencastOwners.delete(targetId);
+        json(surface.ws, { type: "command", relayId: `cleanup-${++relaySequence}`, message: { id: 0, method: "Page.stopScreencast" } });
+      }
+    }
+    for (const [relayId, item] of pending) {
+      if (item.client !== client || item.command.sessionId !== sessionId)
+        continue;
+      clearTimeout(item.timer);
+      pending.delete(relayId);
+      sendError(client, item.command, { code: -32001, message: "Session detached" });
+    }
+    json(client.ws, { ...parent ? { sessionId: parent } : {}, method: "Target.detachedFromTarget", params: { sessionId, ...targetId ? { targetId } : {} } });
+  };
+  const contextSurfaces = (browserContextId) => {
+    const key = typeof browserContextId === "string" ? browserContextId : "default";
+    if (key !== "default" && !contexts?.ids().includes(key))
+      return void 0;
+    return [...surfaces.values()].filter((surface) => (surface.contextId ?? "default") === key);
+  };
+  const fanOut = (client, command, targets, params = command.params) => Promise.all(targets.map((surface) => new Promise((resolve) => {
+    const relayId = `fan-${++relaySequence}`;
+    const timer = setTimeout(() => {
+      pending.delete(relayId);
+      resolve({ id: command.id, error: { code: -32e3, message: "Surface command timed out" } });
+    }, options.commandTimeoutMs ?? 3e4);
+    pending.set(relayId, { client, command, surface, timer, resolve });
+    json(surface.ws, { type: "command", relayId, message: { id: command.id, method: command.method, params } });
+  })));
+  const firstError = (responses) => {
+    const failed = responses.find((response) => response.error);
+    if (failed)
+      throw new Error(failed.error.message);
+  };
+  const handleBrowserCommand = (client, command) => {
+    const params = command.params ?? {};
+    const toPage = (surface) => {
+      if (command.method === "Target.getTargetInfo" && typeof params.targetId !== "string")
+        sendResponse(client, command, { targetInfo: pageInfo(surface) });
+      else
+        forward(client, command, surface);
+    };
+    if (client.directSurfaceId) {
+      const surface = surfaces.get(client.directSurfaceId);
+      if (!surface)
+        return sendError(client, command, { code: -32e3, message: "Target closed" });
+      toPage(surface);
+      return;
+    }
+    if (command.sessionId && !client.browserSessions.has(command.sessionId)) {
+      const targetId = client.sessions.get(command.sessionId);
+      const surface = targetId ? surfaces.get(targetId) : void 0;
+      if (!surface)
+        return sendError(client, command, { code: -32001, message: "No session with given id" });
+      if (command.method === "Target.setAutoAttach") {
+        const parent = command.sessionId;
+        if (params.autoAttach === true) {
+          client.autoAttach.add(parent);
+          for (const worker of surfaces.values()) {
+            if (!autoAttaches(client, parent, worker))
+              continue;
+            if (![...client.sessions].some(([id, target]) => target === worker.description.id && client.parents.get(id) === parent)) {
+              client.automaticSessions.add(attach(client, worker, parent));
+            }
+          }
+        } else {
+          client.autoAttach.delete(parent);
+          for (const id of [...client.automaticSessions])
+            if (client.parents.get(id) === parent)
+              detach(client, id);
+        }
+        sendResponse(client, command);
+        return;
+      }
+      toPage(surface);
+      return;
+    }
+    const hostReply = (operation) => {
+      void operation.then((result) => sendResponse(client, command, result), (error) => sendError(client, command, {
+        code: -32e3,
+        message: error instanceof Error ? error.message : String(error)
+      }));
+    };
+    switch (command.method) {
+      case "Target.createTarget":
+        if (!pages)
+          sendError(client, command);
+        else
+          hostReply(pages.create(`${client.id}:${command.sessionId ?? ""}`, params).then((targetId) => ({ targetId })));
+        break;
+      case "Target.closeTarget":
+        if (!pages)
+          sendError(client, command);
+        else if (typeof params.targetId !== "string")
+          sendError(client, command, { code: -32602, message: "targetId must be a string" });
+        else
+          hostReply(pages.closeTarget(params.targetId).then(() => ({ success: true })));
+        break;
+      case "Target.getBrowserContexts":
+        sendResponse(client, command, { browserContextIds: contexts?.ids() ?? [] });
+        break;
+      case "Target.createBrowserContext":
+        if (!contexts)
+          sendError(client, command);
+        else
+          hostReply(contexts.create(`${client.id}:${command.sessionId ?? ""}`, params).then((browserContextId) => ({ browserContextId })));
+        break;
+      case "Target.disposeBrowserContext":
+        if (!contexts)
+          sendError(client, command);
+        else if (typeof params.browserContextId !== "string")
+          sendError(client, command, { code: -32602, message: "browserContextId must be a string" });
+        else
+          hostReply(contexts.dispose(params.browserContextId).then(() => ({})));
+        break;
+      case "Target.attachToBrowserTarget": {
+        const sessionId = globalThis.crypto.randomUUID().replaceAll("-", "");
+        client.browserSessions.add(sessionId);
+        client.parents.set(sessionId, command.sessionId ?? "");
+        sendResponse(client, command, { sessionId });
+        break;
+      }
+      case "Browser.getVersion":
+        sendResponse(client, command, {
+          jsVersion: "0",
+          // The browser the pages run in, when the dispatcher runs in one.
+          product: `Chrome/${/Chrome\/([\d.]+)/u.exec(globalThis.navigator?.userAgent ?? "")?.[1] ?? "136.0.0.0"}`,
+          protocolVersion: "1.3",
+          revision: "@almostcdp",
+          userAgent: globalThis.navigator?.userAgent ?? "Mozilla/5.0 AlmostCDP/0.1.0"
+        });
+        break;
+      case "Browser.getBrowserCommandLine":
+        sendResponse(client, command, { arguments: [] });
+        break;
+      case "Browser.grantPermissions":
+      case "Browser.resetPermissions": {
+        const key = typeof params.browserContextId === "string" ? params.browserContextId : "default";
+        const targets = contextSurfaces(params.browserContextId);
+        if (!targets) {
+          sendError(client, command, { code: -32e3, message: "Failed to find browser context for id" });
+          break;
+        }
+        if (command.method === "Browser.resetPermissions")
+          contextGrants.delete(key);
+        else
+          contextGrants.set(key, [...contextGrants.get(key) ?? [], params]);
+        hostReply(fanOut(client, command, targets).then((responses) => {
+          firstError(responses);
+          return {};
+        }));
+        break;
+      }
+      case "Storage.getCookies":
+      case "Storage.setCookies":
+      case "Storage.clearCookies": {
+        const targets = contextSurfaces(params.browserContextId);
+        if (!targets) {
+          sendError(client, command, { code: -32e3, message: "Failed to find browser context for id" });
+          break;
+        }
+        const cookies = Array.isArray(params.cookies) ? params.cookies : [];
+        const refusal = !targets.length ? "no surface of the context is open to reach its cookies" : cookies.some((cookie) => cookie.httpOnly === true) ? "HttpOnly cookies are invisible to scripts and cannot be set from a DOM surface" : void 0;
+        if (refusal) {
+          sendError(client, command, { code: -32e3, message: `${command.method} is unavailable on a DOM surface: ${refusal}` });
+          break;
+        }
+        const setting = command.method === "Storage.setCookies";
+        hostReply(fanOut(client, command, targets, setting ? { ...params, [FAN_OUT_PARAM]: true } : params).then((responses) => {
+          firstError(responses);
+          if (command.method === "Storage.getCookies") {
+            const merged = /* @__PURE__ */ new Map();
+            for (const response of responses) {
+              for (const cookie of response.result?.cookies ?? []) {
+                merged.set(`${String(cookie.name)}\0${String(cookie.domain)}\0${String(cookie.path)}`, cookie);
+              }
+            }
+            return { cookies: [...merged.values()] };
+          }
+          if (setting) {
+            const applied = new Set(responses.flatMap((response) => response.result?.applied ?? []));
+            const missing = cookies.filter((_, index) => !applied.has(index)).map((cookie) => String(cookie.domain ?? cookie.url ?? ""));
+            if (missing.length)
+              throw new Error(`Storage.setCookies is unavailable on a DOM surface: no open surface of the context serves ${missing.join(", ")}`);
+          }
+          return {};
+        }));
+        break;
+      }
+      case "Browser.setDownloadBehavior": {
+        if (!options.downloadHost) {
+          sendError(client, command, { code: -32e3, message: "Download policy requires a host download adapter; a live DOM surface cannot enforce it" });
+          break;
+        }
+        const behavior = String(params.behavior ?? "");
+        if (!["default", "deny", "allow", "allowAndName"].includes(behavior)) {
+          sendError(client, command, { code: -32602, message: `Invalid download behavior: ${behavior}` });
+          break;
+        }
+        const downloadPath = typeof params.downloadPath === "string" && params.downloadPath ? params.downloadPath : void 0;
+        if ((behavior === "allow" || behavior === "allowAndName") && !downloadPath) {
+          sendError(client, command, { code: -32602, message: "downloadPath is required for allow and allowAndName" });
+          break;
+        }
+        const targets = contextSurfaces(params.browserContextId);
+        if (!targets) {
+          sendError(client, command, { code: -32e3, message: "Failed to find browser context for id" });
+          break;
+        }
+        const key = typeof params.browserContextId === "string" ? params.browserContextId : "default";
+        const listeners = (downloadPolicies.get(key)?.listeners ?? []).filter((listener) => listener.client !== client || listener.sessionId !== command.sessionId);
+        if (params.eventsEnabled === true)
+          listeners.push({ client, sessionId: command.sessionId });
+        const policy = { behavior, downloadPath, listeners };
+        downloadPolicies.set(key, policy);
+        hostReply(fanOut(client, command, targets, policyCommand(policy).params).then((responses) => {
+          firstError(responses);
+          return {};
+        }));
+        break;
+      }
+      case "Browser.cancelDownload": {
+        if (!options.downloadHost) {
+          sendError(client, command, unavailableCommand(command.method));
+          break;
+        }
+        const guid = String(params.guid ?? "");
+        const surface = surfaces.get(downloadsInFlight.get(guid) ?? "");
+        if (!surface) {
+          sendError(client, command, { code: -32e3, message: `Browser.cancelDownload: no in-flight download with guid ${guid}` });
+          break;
+        }
+        hostReply(fanOut(client, command, [surface], { guid }).then((responses) => {
+          firstError(responses);
+          return {};
+        }));
+        break;
+      }
+      case "Target.getTargets":
+        sendResponse(client, command, { targetInfos: [...surfaces.values()].map(targetInfo) });
+        break;
+      case "Target.getTargetInfo": {
+        const id = typeof params.targetId === "string" ? params.targetId : browserId;
+        if (id === browserId) {
+          sendResponse(client, command, { targetInfo: { targetId: browserId, type: "browser", title: "", url: "", attached: true, canAccessOpener: false } });
+          break;
+        }
+        const surface = id ? surfaces.get(id) : void 0;
+        if (!surface)
+          sendError(client, command, { code: -32e3, message: "No target with given id" });
+        else
+          sendResponse(client, command, { targetInfo: pageInfo(surface) });
+        break;
+      }
+      case "Target.setDiscoverTargets": {
+        const parent = command.sessionId ?? "";
+        const wasDiscovering = client.discover.has(parent);
+        if (params.discover === true)
+          client.discover.add(parent);
+        else
+          client.discover.delete(parent);
+        sendResponse(client, command);
+        if (params.discover === true && !wasDiscovering) {
+          for (const surface of surfaces.values()) {
+            json(client.ws, { ...parent ? { sessionId: parent } : {}, method: "Target.targetCreated", params: { targetInfo: pageInfo(surface) } });
+          }
+        }
+        break;
+      }
+      case "Target.setAutoAttach": {
+        const parent = command.sessionId ?? "";
+        if (params.autoAttach === true)
+          client.autoAttach.add(parent);
+        else
+          client.autoAttach.delete(parent);
+        if (params.autoAttach === true) {
+          for (const surface of surfaces.values()) {
+            if (!autoAttaches(client, parent, surface))
+              continue;
+            if (![...client.sessions].some(([id, target]) => target === surface.description.id && client.parents.get(id) === parent)) {
+              client.automaticSessions.add(attach(client, surface, command.sessionId));
+            }
+          }
+        } else {
+          for (const id of [...client.automaticSessions])
+            if (client.parents.get(id) === parent)
+              detach(client, id);
+        }
+        sendResponse(client, command);
+        break;
+      }
+      case "Target.attachToTarget": {
+        const id = String(params.targetId ?? "");
+        const surface = surfaces.get(id);
+        if (!surface)
+          sendError(client, command, { code: -32e3, message: "No target with given id" });
+        else {
+          const sessionId = attach(client, surface, command.sessionId);
+          sendResponse(client, command, { sessionId });
+        }
+        break;
+      }
+      case "Target.activateTarget": {
+        const surface = surfaces.get(String(params.targetId ?? ""));
+        if (!surface)
+          sendError(client, command, { code: -32e3, message: "No target with given id" });
+        else
+          forward(client, command, surface);
+        break;
+      }
+      case "Target.detachFromTarget": {
+        const sessionId = String(params.sessionId ?? "");
+        const targetId = client.sessions.get(sessionId);
+        if (!targetId && !client.browserSessions.has(sessionId) || client.parents.get(sessionId) !== (command.sessionId ?? "")) {
+          sendError(client, command, { code: -32001, message: "No session with given id" });
+          break;
+        }
+        detach(client, sessionId);
+        sendResponse(client, command);
+        break;
+      }
+      default:
+        sendError(client, command, unavailableCommand(command.method) ?? unsupported(command.method));
+    }
+  };
+  const failPending = (surface, message) => {
+    for (const [relayId, item] of pending) {
+      if (item.surface !== surface)
+        continue;
+      clearTimeout(item.timer);
+      pending.delete(relayId);
+      if (item.resolve)
+        item.resolve({ id: item.command.id, error: { code: -32e3, message } });
+      else
+        sendError(item.client, item.command, { code: -32e3, message });
+    }
+  };
+  const destroySurface = (id) => {
+    const surface = surfaces.get(id);
+    if (!surface)
+      return;
+    const succession = successions.get(id);
+    if (succession?.suspended)
+      clearTimeout(succession.suspended.timer);
+    successions.delete(id);
+    surfaces.delete(id);
+    screencastOwners.delete(id);
+    failPending(surface, "Target closed");
+    for (const viewer of castViewers.get(id) ?? [])
+      viewer.close(1001, "Target closed");
+    for (const client of clients) {
+      if (client.directSurfaceId === id) {
+        client.subscriptions.clear();
+        client.subscriptionChanges.clear();
+        client.ws.close(1001, "Target closed");
+        continue;
+      }
+      for (const [sessionId, targetId] of [...client.sessions]) {
+        if (targetId === id)
+          detach(client, sessionId);
+      }
+      for (const parent of client.discover) {
+        json(client.ws, { ...parent ? { sessionId: parent } : {}, method: "Target.targetDestroyed", params: { targetId: id } });
+      }
+    }
+  };
+  const suspendSurface = (id, succession) => {
+    const surface = surfaces.get(id);
+    const buffer = [];
+    surface.ws = {
+      readyState: 1,
+      send: (data) => {
+        buffer.push(data);
+      },
+      close: () => destroySurface(id),
+      on: () => void 0
+    };
+    failPending(surface, "Inspected target navigated or closed");
+    for (const viewer of castViewers.get(id) ?? [])
+      viewer.close(1012, "Document replaced; reconnect");
+    succession.suspended = { buffer, timer: setTimeout(() => destroySurface(id), successionGraceMs) };
+  };
+  const connect = (ws, path, access = "control") => {
+    const requestUrl = new URL(path, "http://localhost");
+    if (access === "view" && !requestUrl.pathname.startsWith("/casts/")) {
+      ws.close(1008, "View-only access permits only casting");
+      return;
+    }
+    if (requestUrl.pathname === "/__almostcdp/surface") {
+      if (requestUrl.searchParams.get("token") !== surfaceToken) {
+        ws.close(1008, "invalid surface token");
+        return;
+      }
+      let registeredId;
+      const subsurfaces = /* @__PURE__ */ new Map();
+      ws.on("close", () => {
+        for (const peer of [...subsurfaces.values()])
+          peer.closed();
+      });
+      ws.on("message", (bytes) => {
+        let message;
+        try {
+          message = JSON.parse(bytes.toString());
+          if (!message || typeof message !== "object")
+            throw new Error("Invalid message");
+        } catch {
+          ws.close(1003, "invalid JSON");
+          return;
+        }
+        if (message.type === "hello") {
+          if (!message.surface || typeof message.surface.title !== "string" || typeof message.surface.url !== "string" || message.surface.id !== void 0 && (typeof message.surface.id !== "string" || !/^[\w-]+$/.test(message.surface.id))) {
+            ws.close(1008, "invalid surface description");
+            return;
+          }
+          const id = message.surface.id ?? registeredId ?? globalThis.crypto.randomUUID().replaceAll("-", "");
+          const token = message.succession?.token;
+          if (message.succession !== void 0 && (typeof token !== "string" || token.length < 16)) {
+            ws.close(1008, "invalid succession token");
+            return;
+          }
+          const succession = successions.get(id);
+          if (!registeredId && succession && surfaces.has(id) && surfaces.get(id).ws !== ws) {
+            if (token !== succession.token) {
+              ws.close(1008, "surface identity already registered");
+              return;
+            }
+            if (!succession.suspended) {
+              const predecessor = surfaces.get(id).ws;
+              suspendSurface(id, succession);
+              predecessor.close(1e3, "Document replaced by its successor");
+            }
+            const surface2 = surfaces.get(id);
+            clearTimeout(succession.suspended.timer);
+            const queued = succession.suspended.buffer;
+            succession.suspended = void 0;
+            registeredId = id;
+            surface2.ws = ws;
+            surface2.description.title = message.surface.title;
+            surface2.description.url = message.surface.url;
+            json(ws, {
+              type: "resume",
+              state: succession.state,
+              ...succession.loaderId ? { loaderId: succession.loaderId, navigationType: succession.navigationType } : {}
+            });
+            succession.loaderId = void 0;
+            succession.navigationType = void 0;
+            for (const data of queued)
+              if (ws.readyState === 1)
+                ws.send(data);
+            for (const client2 of clients) {
+              const observers = new Set(client2.discover);
+              for (const [sessionId, targetId] of client2.sessions)
+                if (targetId === id)
+                  observers.add(client2.parents.get(sessionId) ?? "");
+              for (const parent of observers) {
+                json(client2.ws, { ...parent ? { sessionId: parent } : {}, method: "Target.targetInfoChanged", params: { targetInfo: targetInfo(surface2) } });
+              }
+            }
+            return;
+          }
+          if (registeredId && registeredId !== id || surfaces.has(id) && surfaces.get(id).ws !== ws) {
+            ws.close(1008, "surface identity already registered");
+            return;
+          }
+          const parentId = subsurfaceParents.get(ws);
+          if (pages && parentId === void 0 && !pages.acceptsSurface(id)) {
+            ws.close(1008, "Page allocation is no longer active");
+            return;
+          }
+          if (token !== void 0 && !registeredId) {
+            successions.set(id, { token, state: null });
+            json(ws, { type: "resume", state: null });
+          }
+          const existed = surfaces.has(id);
+          registeredId = id;
+          const surface = {
+            contextId: parentId !== void 0 ? surfaces.get(parentId)?.contextId : pages?.context(id),
+            ...parentId !== void 0 ? { parentId } : {},
+            description: {
+              id,
+              title: message.surface.title,
+              type: message.surface.type ?? "page",
+              url: message.surface.url
+            },
+            ws
+          };
+          surfaces.set(id, surface);
+          const openerMark = pages?.openerMark(id);
+          const ownMark = pages?.ownMark(id);
+          if (openerMark || ownMark)
+            json(ws, { type: "opener", ...openerMark ? { mark: openerMark } : {}, ...ownMark ? { own: ownMark } : {} });
+          for (const client2 of clients) {
+            const observers = new Set(client2.discover);
+            if (existed) {
+              for (const [sessionId, targetId] of client2.sessions)
+                if (targetId === id)
+                  observers.add(client2.parents.get(sessionId) ?? "");
+            }
+            for (const parent of observers) {
+              json(client2.ws, { ...parent ? { sessionId: parent } : {}, method: existed ? "Target.targetInfoChanged" : "Target.targetCreated", params: { targetInfo: pageInfo(surface) } });
+            }
+            if (!existed) {
+              for (const parent of client2.autoAttach)
+                if (autoAttaches(client2, parent, surface))
+                  client2.automaticSessions.add(attach(client2, surface, parent || void 0));
+            }
+          }
+          if (!existed) {
+            const policy = downloadPolicies.get(surface.contextId ?? "default");
+            if (policy && policy.behavior !== "default") {
+              json(ws, { type: "command", relayId: `cleanup-${++relaySequence}`, message: policyCommand(policy) });
+            }
+            for (const grant of contextGrants.get(surface.contextId ?? "default") ?? []) {
+              json(ws, { type: "command", relayId: `cleanup-${++relaySequence}`, message: { id: 0, method: "Browser.grantPermissions", params: grant } });
+            }
+          }
+          return;
+        }
+        if (message.type === "succession-state") {
+          const succession = registeredId ? successions.get(registeredId) : void 0;
+          if (!succession || surfaces.get(registeredId)?.ws !== ws)
+            return;
+          if (!message.state || typeof message.state !== "object" || Array.isArray(message.state)) {
+            ws.close(1008, "invalid succession state");
+            return;
+          }
+          succession.state = message.state;
+          return;
+        }
+        if (message.type === "response") {
+          const item = pending.get(message.relayId);
+          if (!item || item.surface.ws !== ws)
+            return;
+          if (!message.message || typeof message.message !== "object") {
+            ws.close(1008, "invalid response");
+            return;
+          }
+          pending.delete(message.relayId);
+          clearTimeout(item.timer);
+          const navigated = successions.get(item.surface.description.id);
+          if (navigated && !message.message.error && (item.command.method === "Page.navigate" || item.command.method === "Page.reload")) {
+            const loaderId = message.message.result?.loaderId;
+            navigated.loaderId = typeof loaderId === "string" ? loaderId : void 0;
+            navigated.navigationType = item.command.method === "Page.reload" ? "reload" : "typed";
+          }
+          if (item.resolve) {
+            item.resolve(message.message);
+            return;
+          }
+          item.settleSubscription?.(!message.message.error);
+          item.settleCapture?.(!message.message.error);
+          const response = { ...message.message, id: item.command.id };
+          if (item.command.sessionId)
+            response.sessionId = item.command.sessionId;
+          json(item.client.ws, response);
+          return;
+        }
+        if (message.type === "cast" && registeredId) {
+          for (const viewer of castViewers.get(registeredId) ?? [])
+            json(viewer, message.event);
+          return;
+        }
+        if (message.type === "sub" && registeredId && typeof message.sub === "string") {
+          const pageId = registeredId;
+          let peer = subsurfaces.get(message.sub);
+          if (message.open === true && !peer) {
+            const sub = message.sub;
+            peer = new SubsurfacePeer((frame2) => json(ws, { type: "sub", sub, ...frame2 }));
+            subsurfaces.set(sub, peer);
+            subsurfaceParents.set(peer, pageId);
+            peer.on("close", () => subsurfaces.delete(sub));
+            connect(peer, `/__almostcdp/surface?token=${encodeURIComponent(surfaceToken)}`);
+          }
+          if (typeof message.data === "string")
+            peer?.received(message.data);
+          if (message.close === true)
+            peer?.closed();
+          return;
+        }
+        if (message.type === "close-window" && registeredId) {
+          const closing = registeredId;
+          void pages?.closeTarget(closing).catch((error) => console.warn(`AlmostCDP: window.close() closed no page: ${error instanceof Error ? error.message : String(error)}`));
+          return;
+        }
+        if (message.type === "open-window" && registeredId) {
+          const openerId = registeredId;
+          if (!pages || typeof message.url !== "string")
+            return;
+          const owner = pages.owner(openerId) ?? `popup:${openerId}`;
+          const contextId = surfaces.get(openerId)?.contextId;
+          const mark = typeof message.opener === "string" && /^[\w-]{16,}$/u.test(message.opener) ? message.opener : void 0;
+          const own = typeof message.mark === "string" && /^[\w-]{16,}$/u.test(message.mark) ? message.mark : void 0;
+          void pages.create(owner, { url: message.url, ...contextId && contextId !== "default" ? { browserContextId: contextId } : {} }, openerId, mark, own).catch((error) => console.warn(`AlmostCDP: window.open(${JSON.stringify(message.url)}) opened no page: ${error instanceof Error ? error.message : String(error)}`));
+          return;
+        }
+        if (message.type === "download" && registeredId) {
+          const surfaceId = registeredId;
+          const contextId = surfaces.get(surfaceId)?.contextId;
+          const policy = downloadPolicies.get(contextId ?? "default");
+          const reply = (written) => json(ws, { type: "download-written", ...written });
+          if (!options.downloadHost || !policy?.downloadPath || policy.behavior !== "allow" && policy.behavior !== "allowAndName" || typeof message.guid !== "string" || typeof message.data !== "string") {
+            reply({ error: "downloads are not accepted for this context", guid: String(message.guid) });
+            return;
+          }
+          const name = policy.behavior === "allowAndName" ? message.guid : String(message.suggestedFilename ?? "").replace(/[\\/]/g, "_") || message.guid;
+          const filePath = `${policy.downloadPath.replace(/[\\/]+$/, "")}/${name}`;
+          void options.downloadHost.write(contextId, filePath, base64ToBytes(message.data)).then(() => reply({ filePath, guid: message.guid }), (error) => reply({ error: error instanceof Error ? error.message : String(error), guid: message.guid }));
+          return;
+        }
+        if (message.type === "event" && registeredId) {
+          if (!message.message || typeof message.message.method !== "string") {
+            ws.close(1008, "invalid event");
+            return;
+          }
+          if (message.message.method.startsWith("Browser.download")) {
+            const params = message.message.params ?? {};
+            const guid = String(params.guid ?? "");
+            if (message.message.method === "Browser.downloadWillBegin")
+              downloadsInFlight.set(guid, registeredId);
+            else if (params.state === "completed" || params.state === "canceled")
+              downloadsInFlight.delete(guid);
+            const policy = downloadPolicies.get(surfaces.get(registeredId)?.contextId ?? "default");
+            for (const listener of policy?.listeners ?? []) {
+              json(listener.client.ws, { method: message.message.method, params, ...listener.sessionId ? { sessionId: listener.sessionId } : {} });
+            }
+            return;
+          }
+          if (message.message.method === "Page.screencastFrame") {
+            const owner = screencastOwners.get(registeredId);
+            const { sessionId: audience2, ...event2 } = message.message;
+            if (owner && audience2 === `${owner.client.id}:${owner.sessionId ?? "direct"}`)
+              json(owner.client.ws, { ...event2, ...owner.sessionId ? { sessionId: owner.sessionId } : {} });
+            return;
+          }
+          const { sessionId: audience, ...event } = message.message;
+          const domain = event.method.split(".")[0];
+          const requiresSubscription = ["Runtime", "Network", "Log", "DOM", "Page", "Accessibility"].includes(domain);
+          const subscribed = (client2, key) => (!audience || audience === `${client2.id}:${key}`) && (!requiresSubscription || client2.subscriptions.get(key)?.has(domain));
+          for (const client2 of clients) {
+            if (client2.directSurfaceId === registeredId && subscribed(client2, "direct")) {
+              json(client2.ws, event);
+              continue;
+            }
+            for (const [sessionId, targetId] of client2.sessions) {
+              if (targetId === registeredId && subscribed(client2, sessionId))
+                json(client2.ws, { ...event, sessionId });
+            }
+          }
+        }
+      });
+      ws.on("close", () => {
+        if (!registeredId || surfaces.get(registeredId)?.ws !== ws)
+          return;
+        const succession = successions.get(registeredId);
+        if (succession)
+          suspendSurface(registeredId, succession);
+        else
+          destroySurface(registeredId);
+      });
+      return;
+    }
+    const pageMatch = requestUrl.pathname.match(/^\/devtools\/page\/([^/]+)$/);
+    const browserMatch = requestUrl.pathname.match(/^\/devtools\/browser\/([^/]+)$/);
+    const castMatch = requestUrl.pathname.match(/^\/casts\/([^/]+)$/);
+    if (castMatch) {
+      const surfaceId = castMatch[1];
+      if (!surfaces.has(surfaceId)) {
+        ws.close(1013, "target not available");
+        return;
+      }
+      const viewers = castViewers.get(surfaceId) ?? /* @__PURE__ */ new Set();
+      viewers.add(ws);
+      castViewers.set(surfaceId, viewers);
+      json(surfaces.get(surfaceId).ws, { type: "cast-reset" });
+      ws.on("message", (bytes) => {
+        if (access === "view") {
+          ws.close(1008, "View-only access cannot send input");
+          return;
+        }
+        const surface = surfaces.get(surfaceId);
+        if (!surface)
+          return;
+        let input;
+        try {
+          input = JSON.parse(bytes.toString());
+        } catch {
+          ws.close(1003, "invalid JSON");
+          return;
+        }
+        if (typeof input.method !== "string" || !input.method.startsWith("Input.")) {
+          ws.close(1008, "cast input must be a CDP Input command");
+          return;
+        }
+        const payload = {
+          message: {
+            id: 0,
+            method: input.method,
+            params: typeof input.params === "object" && input.params ? input.params : {}
+          },
+          relayId: `cast-${++relaySequence}`,
+          type: "command"
+        };
+        json(surface.ws, payload);
+      });
+      ws.on("close", () => {
+        viewers.delete(ws);
+        if (!viewers.size)
+          castViewers.delete(surfaceId);
+      });
+      return;
+    }
+    if (!pageMatch && (!browserMatch || browserMatch[1] !== browserId)) {
+      ws.close(1008, "unknown endpoint");
+      return;
+    }
+    if (pageMatch && !surfaces.has(pageMatch[1])) {
+      ws.close(1008, "unknown target");
+      return;
+    }
+    const client = {
+      id: globalThis.crypto.randomUUID(),
+      autoAttach: /* @__PURE__ */ new Set(),
+      automaticSessions: /* @__PURE__ */ new Set(),
+      parents: /* @__PURE__ */ new Map(),
+      browserSessions: /* @__PURE__ */ new Set(),
+      subscriptions: /* @__PURE__ */ new Map(),
+      subscriptionChanges: /* @__PURE__ */ new Map(),
+      directSurfaceId: pageMatch?.[1],
+      discover: /* @__PURE__ */ new Set(),
+      sessions: /* @__PURE__ */ new Map(),
+      ws
+    };
+    clients.add(client);
+    ws.on("message", (bytes) => {
+      let command;
+      try {
+        command = JSON.parse(bytes.toString());
+        if (!command || !Number.isSafeInteger(command.id) || typeof command.method !== "string" || command.params !== void 0 && (!command.params || typeof command.params !== "object" || Array.isArray(command.params)) || command.sessionId !== void 0 && typeof command.sessionId !== "string")
+          throw new Error("Invalid command");
+      } catch {
+        ws.close(1003, "invalid JSON");
+        return;
+      }
+      commandCounts.set(command.method, (commandCounts.get(command.method) ?? 0) + 1);
+      handleBrowserCommand(client, command);
+    });
+    ws.on("close", () => {
+      clients.delete(client);
+      for (const policy of downloadPolicies.values())
+        policy.listeners = policy.listeners.filter((listener) => listener.client !== client);
+      for (const scope of ["", ...client.browserSessions]) {
+        pages?.disconnect(`${client.id}:${scope}`);
+        void contexts?.disconnect(`${client.id}:${scope}`).catch(() => {
+        });
+      }
+      for (const [sessionId, targetId] of client.sessions) {
+        const surface = surfaces.get(targetId);
+        if (surface)
+          json(surface.ws, { type: "session-closed", sessionId: `${client.id}:${sessionId}` });
+      }
+      if (client.directSurfaceId) {
+        const surface = surfaces.get(client.directSurfaceId);
+        if (surface)
+          json(surface.ws, { type: "session-closed", sessionId: `${client.id}:direct` });
+      }
+      for (const [targetId, owner] of screencastOwners) {
+        if (owner.client !== client)
+          continue;
+        screencastOwners.delete(targetId);
+        const surface = surfaces.get(targetId);
+        if (surface)
+          json(surface.ws, { type: "command", relayId: `cleanup-${++relaySequence}`, message: { id: 0, method: "Page.stopScreencast" } });
+      }
+      for (const [relayId, item] of pending) {
+        if (item.client === client) {
+          clearTimeout(item.timer);
+          pending.delete(relayId);
+        }
+      }
+    });
+  };
+  return {
+    connect,
+    targets: () => [...surfaces.values()].map((surface) => ({ ...surface.description })),
+    compatibility: () => ({
+      manifest: SUPPORT_MANIFEST,
+      observedCommands: Object.fromEntries([...commandCounts].sort(([a], [b]) => a.localeCompare(b)))
+    }),
+    async close() {
+      for (const item of pending.values())
+        clearTimeout(item.timer);
+      pending.clear();
+      for (const client of clients)
+        client.ws.close(1001, "server closing");
+      for (const surface of surfaces.values())
+        surface.ws.close(1001, "server closing");
+      for (const viewers of castViewers.values()) {
+        for (const viewer of viewers)
+          viewer.close(1001, "server closing");
+      }
+      const cleanup = await Promise.allSettled([pages?.close(), contexts?.close()]);
+      const errors = cleanup.filter((result) => result.status === "rejected");
+      if (errors.length === 1)
+        throw errors[0].reason;
+      if (errors.length)
+        throw new AggregateError(errors.map((result) => result.reason), "Host cleanup failed");
+    }
+  };
+}
+
+// node_modules/@volter/almostcdp/dist/socket-server.js
+var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var MAX_HEADER_BYTES = 64 * 1024;
+var encoder2 = new TextEncoder();
+function createSocketEndpoint(options) {
+  const browserId = globalThis.crypto.randomUUID().replaceAll("-", "");
+  const surfaceToken = randomHex(24);
+  const dispatcher = createDispatcher({ ...options, browserId, surfaceToken });
+  const sockets = /* @__PURE__ */ new Set();
+  let closed = false;
+  const source = { browserId, targets: dispatcher.targets, compatibility: dispatcher.compatibility };
+  const serve = (socket) => {
+    if (closed) {
+      socket.close();
+      return;
+    }
+    sockets.add(socket);
+    socket.onClose(() => sockets.delete(socket));
+    let head = new Uint8Array();
+    let upgraded;
+    let pending;
+    let answered = false;
+    const answer = (status, body, headOnly = false) => {
+      answered = true;
+      head = new Uint8Array();
+      respond(socket, status, body, headOnly);
+    };
+    socket.onData((bytes) => {
+      if (upgraded) {
+        upgraded(bytes);
+        return;
+      }
+      if (pending) {
+        pending.push(bytes);
+        return;
+      }
+      if (answered)
+        return;
+      const from = Math.max(0, head.byteLength - 3);
+      head = concat(head, bytes);
+      const end = indexOfHeaderEnd(head, from);
+      if (end < 0) {
+        if (head.byteLength > MAX_HEADER_BYTES) {
+          console.warn(`CDP endpoint: a connection sent ${head.byteLength} bytes with no HTTP request header; it is answered 431 and closed. It starts ${JSON.stringify(new TextDecoder().decode(head.subarray(0, 32)))}.`);
+          answer(431, { error: "request header too large" });
+        }
+        return;
+      }
+      const request = parseRequest(new TextDecoder().decode(head.subarray(0, end)));
+      const rest = head.subarray(end + 4);
+      if (!request) {
+        answer(400, { error: "malformed request" });
+        return;
+      }
+      const access = options.authorize ? options.authorize(request) : "control";
+      if (!access) {
+        answer(401, { error: "unauthorized" });
+        return;
+      }
+      if ((request.headers.upgrade ?? "").toLowerCase() === "websocket") {
+        const key = request.headers["sec-websocket-key"];
+        if (request.method !== "GET" || !key || request.headers["sec-websocket-version"] !== "13" || !/\bupgrade\b/i.test(request.headers.connection ?? "")) {
+          answer(400, { error: "invalid WebSocket handshake" });
+          return;
+        }
+        pending = rest.byteLength ? [rest] : [];
+        void acceptKey(key).then((accept) => {
+          socket.write(encoder2.encode(`HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: ${accept}\r
+\r
+`));
+          const peer = new SocketPeer(socket, options.maxMessageBytes ?? 32 * 1024 * 1024);
+          upgraded = (chunk) => peer.receive(chunk);
+          dispatcher.connect(peer, request.path, access);
+          for (const chunk of pending)
+            peer.receive(chunk);
+          pending = void 0;
+        }, () => socket.close());
+        return;
+      }
+      if (access !== "control" || request.method !== "GET" && request.method !== "HEAD") {
+        answer(access !== "control" ? 403 : 405, { error: "discovery is read-only and requires control access" });
+        return;
+      }
+      const { status, body } = discoveryDocument(source, options.address, new URL(request.path, "http://localhost").pathname);
+      answer(status, body, request.method === "HEAD");
+    });
+  };
+  return {
+    browserId,
+    serve,
+    attachSurface: (peer) => dispatcher.connect(peer, `/__almostcdp/surface?token=${surfaceToken}`),
+    attachClient: (peer) => dispatcher.connect(peer, `/devtools/browser/${browserId}`),
+    discovery: (pathname, address = options.address) => discoveryDocument(source, address, pathname),
+    connect: (peer, path, access = "control") => {
+      if (new URL(path, "http://localhost").pathname.startsWith("/__almostcdp/")) {
+        peer.close(1008, "Surface registration is the host's");
+        return;
+      }
+      dispatcher.connect(peer, path, access);
+    },
+    targets: dispatcher.targets,
+    compatibility: dispatcher.compatibility,
+    async close() {
+      closed = true;
+      for (const socket of [...sockets])
+        socket.close();
+      await dispatcher.close();
+    }
+  };
+}
+var SocketPeer = class {
+  socket;
+  maxMessageBytes;
+  readyState = 1;
+  buffer = new Uint8Array();
+  fragments = [];
+  fragmentBytes = 0;
+  fragmented = false;
+  messageListeners = [];
+  closeListeners = [];
+  decoder = new TextDecoder("utf-8", { fatal: true });
+  constructor(socket, maxMessageBytes) {
+    this.socket = socket;
+    this.maxMessageBytes = maxMessageBytes;
+    socket.onClose(() => this.finish());
+  }
+  on(event, listener) {
+    if (event === "message")
+      this.messageListeners.push(listener);
+    else
+      this.closeListeners.push(listener);
+  }
+  send(data) {
+    if (this.readyState !== 1)
+      return;
+    this.socket.write(frame(1, encoder2.encode(data)));
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState !== 1)
+      return;
+    const reasonBytes = encoder2.encode(reason).subarray(0, 123);
+    const payload = new Uint8Array(2 + reasonBytes.byteLength);
+    new DataView(payload.buffer).setUint16(0, code);
+    payload.set(reasonBytes, 2);
+    this.readyState = 2;
+    this.socket.write(frame(8, payload));
+    this.socket.close();
+    this.finish();
+  }
+  receive(bytes) {
+    if (this.readyState === 3)
+      return;
+    this.buffer = concat(this.buffer, bytes);
+    for (; ; ) {
+      if (this.buffer.byteLength < 2)
+        return;
+      const first = this.buffer[0], second = this.buffer[1];
+      const fin = (first & 128) !== 0, opcode = first & 15;
+      if ((first & 112) !== 0 || (second & 128) === 0) {
+        this.close(1002, "Protocol error");
+        return;
+      }
+      let length = second & 127, offset = 2;
+      if (length === 126) {
+        if (this.buffer.byteLength < 4)
+          return;
+        length = this.buffer[2] << 8 | this.buffer[3];
+        offset = 4;
+      } else if (length === 127) {
+        if (this.buffer.byteLength < 10)
+          return;
+        const view = new DataView(this.buffer.buffer, this.buffer.byteOffset + 2, 8);
+        if (view.getUint32(0) !== 0) {
+          this.close(1009, "Message too big");
+          return;
+        }
+        length = view.getUint32(4);
+        offset = 10;
+      }
+      if (length > this.maxMessageBytes) {
+        this.close(1009, "Message too big");
+        return;
+      }
+      if (this.buffer.byteLength < offset + 4 + length)
+        return;
+      const mask = this.buffer.subarray(offset, offset + 4);
+      const payload = this.buffer.slice(offset + 4, offset + 4 + length);
+      for (let index = 0; index < payload.byteLength; index++)
+        payload[index] ^= mask[index & 3];
+      this.buffer = this.buffer.subarray(offset + 4 + length);
+      if (opcode >= 8) {
+        if (!fin || length > 125) {
+          this.close(1002, "Protocol error");
+          return;
+        }
+        if (opcode === 8) {
+          this.close(1e3, "");
+          return;
+        }
+        if (opcode === 9)
+          this.socket.write(frame(10, payload));
+        else if (opcode !== 10) {
+          this.close(1002, "Protocol error");
+          return;
+        }
+        continue;
+      }
+      if (opcode === 2 || opcode === 0 && !this.fragmented || opcode === 1 && this.fragmented || opcode > 2) {
+        this.close(opcode === 2 ? 1003 : 1002, opcode === 2 ? "CDP messages are text" : "Protocol error");
+        return;
+      }
+      this.fragmentBytes += payload.byteLength;
+      if (this.fragmentBytes > this.maxMessageBytes) {
+        this.close(1009, "Message too big");
+        return;
+      }
+      this.fragments.push(payload);
+      this.fragmented = !fin;
+      if (!fin)
+        continue;
+      const message = this.fragments.length === 1 ? this.fragments[0] : this.fragments.reduce(concat, new Uint8Array());
+      this.fragments = [];
+      this.fragmentBytes = 0;
+      let text;
+      try {
+        text = this.decoder.decode(message);
+      } catch {
+        this.close(1007, "Invalid UTF-8");
+        return;
+      }
+      for (const listener of this.messageListeners)
+        listener(text);
+      if (this.readyState !== 1)
+        return;
+    }
+  }
+  finish() {
+    if (this.readyState === 3)
+      return;
+    this.readyState = 3;
+    for (const listener of this.closeListeners)
+      listener();
+  }
+};
+function frame(opcode, payload) {
+  const length = payload.byteLength;
+  const header = length < 126 ? 2 : length < 65536 ? 4 : 10;
+  const out = new Uint8Array(header + length);
+  out[0] = 128 | opcode;
+  if (length < 126)
+    out[1] = length;
+  else if (length < 65536) {
+    out[1] = 126;
+    out[2] = length >> 8;
+    out[3] = length & 255;
+  } else {
+    out[1] = 127;
+    new DataView(out.buffer).setUint32(6, length);
+  }
+  out.set(payload, header);
+  return out;
+}
+function respond(socket, status, body, headOnly = false) {
+  const bytes = encoder2.encode(JSON.stringify(body));
+  const reason = { 200: "OK", 400: "Bad Request", 401: "Unauthorized", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 431: "Request Header Fields Too Large" }[status] ?? "";
+  socket.write(encoder2.encode(`HTTP/1.1 ${status} ${reason}\r
+Content-Type: application/json; charset=UTF-8\r
+Content-Length: ${bytes.byteLength}\r
+Connection: close\r
+\r
+`));
+  if (!headOnly)
+    socket.write(bytes);
+  socket.close();
+}
+function parseRequest(text) {
+  const [line, ...fields] = text.split("\r\n");
+  const match = /^([A-Z]+) (\/\S*) HTTP\/1\.[01]$/.exec(line ?? "");
+  if (!match)
+    return void 0;
+  const headers = {};
+  for (const field of fields) {
+    const colon = field.indexOf(":");
+    if (colon <= 0)
+      return void 0;
+    headers[field.slice(0, colon).trim().toLowerCase()] = field.slice(colon + 1).trim();
+  }
+  return { method: match[1], path: match[2], headers };
+}
+async function acceptKey(key) {
+  const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-1", encoder2.encode(key + GUID)));
+  let binary = "";
+  for (const byte of digest)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function indexOfHeaderEnd(bytes, from = 0) {
+  for (let index = Math.max(3, from + 3); index < bytes.byteLength; index++) {
+    if (bytes[index - 3] === 13 && bytes[index - 2] === 10 && bytes[index - 1] === 13 && bytes[index] === 10)
+      return index - 3;
+  }
+  return -1;
+}
+function concat(left, right) {
+  if (!left.byteLength)
+    return right;
+  const out = new Uint8Array(left.byteLength + right.byteLength);
+  out.set(left);
+  out.set(right, left.byteLength);
+  return out;
+}
+function randomHex(bytes) {
+  return [...globalThis.crypto.getRandomValues(new Uint8Array(bytes))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// node_modules/@volter/almostcdp/dist/message-port.js
+var MessagePortTransport = class extends EventTarget {
+  port;
+  readyState = 1;
+  constructor(port) {
+    super();
+    this.port = port;
+    port.addEventListener("message", this.receive);
+    port.addEventListener("messageerror", this.failed);
+    port.start();
+  }
+  receive = (event) => {
+    const message = event.data;
+    if (message?.type === "close") {
+      this.finish();
+      return;
+    }
+    if (message?.type !== "data" || typeof message.data !== "string") {
+      this.close(1003, "Invalid transport envelope");
+      return;
+    }
+    this.dispatchEvent(new MessageEvent("message", { data: message.data }));
+  };
+  failed = () => {
+    this.close(1003, "MessagePort decode failure");
+  };
+  finish() {
+    if (this.readyState === 3)
+      return;
+    this.readyState = 3;
+    this.port.removeEventListener("message", this.receive);
+    this.port.removeEventListener("messageerror", this.failed);
+    this.port.close();
+    this.dispatchEvent(new Event("close"));
+  }
+  send(data) {
+    if (this.readyState !== 1)
+      throw new Error("MessagePort transport is closed");
+    this.port.postMessage({ type: "data", data });
+  }
+  close(code = 1e3, reason = "Transport closed") {
+    if (this.readyState === 3)
+      return;
+    this.port.postMessage({ type: "close", code, reason });
+    this.finish();
+  }
+  on(event, listener) {
+    this.addEventListener(event, (message) => {
+      if (event === "message")
+        listener(message.data);
+      else
+        listener();
+    });
+  }
+};
+
+// packages/runtime/src/sandbox-protocol.ts
+var SANDBOX_CHANNEL = "supercode-sandbox-v1";
+function isSandboxEnvelope(value, nonce) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.channel === SANDBOX_CHANNEL && candidate.nonce === nonce && typeof candidate.type === "string";
+}
+
+// packages/runtime/src/browser-base64.ts
+function decodedBase64ByteLength(value) {
+  if (value.length % 4 !== 0) return;
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  const dataLength = value.length - padding;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    const data = index < dataLength;
+    const alphabet = code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
+    if (data ? !alphabet : code !== 61) return;
+  }
+  return value.length / 4 * 3 - padding;
+}
+function encodeBase64(value) {
+  const native = value.toBase64;
+  if (typeof native === "function") return native.call(value);
+  let binary = "";
+  for (let offset = 0; offset < value.byteLength; offset += 32768) {
+    binary += String.fromCharCode(...value.subarray(offset, offset + 32768));
+  }
+  return btoa(binary);
+}
+
+// packages/runtime/src/browser-virtual-websocket.ts
+function virtualFrameByteLength(data) {
+  return "bytes" in data ? data.bytes.byteLength : decodedBase64ByteLength(data.base64);
+}
+var OPEN_TIMEOUT_MS = 3e4;
+var MAX_VIRTUAL_WEBSOCKET_FRAME_BYTES = 32 * 1024 * 1024;
+var BrowserVirtualWebSocketHub = class {
+  constructor(registeredPort, registry, connector) {
+    this.registeredPort = registeredPort;
+    this.registry = registry;
+    this.connector = connector;
+  }
+  registeredPort;
+  registry;
+  connector;
+  sockets = /* @__PURE__ */ new Map();
+  closingAll = false;
+  open(id, port, path, protocols, handlers, addressed) {
+    if (this.closingAll) throw new Error("Virtual WebSockets are closing.");
+    if (!Number.isSafeInteger(id) || id < 1) throw new Error("Invalid virtual WebSocket identifier.");
+    const closing = this.sockets.get(id);
+    if (closing && closing.state === 2) this.terminate(id, closing, 1001, "");
+    if (this.sockets.has(id)) throw new Error("Invalid virtual WebSocket identifier.");
+    assertPort(port);
+    if (!this.registeredPort(port)) throw new Error("No virtual server is listening on that WebSocket port.");
+    if (!validPath(path)) throw new Error("Invalid virtual WebSocket request target.");
+    if (!Array.isArray(protocols) || protocols.length > 16 || new Set(protocols).size !== protocols.length || protocols.some((protocol) => typeof protocol !== "string" || !validProtocol(protocol))) {
+      throw new Error("Invalid virtual WebSocket protocol list.");
+    }
+    const socket = {
+      port,
+      state: 0,
+      handlers,
+      timeout: setTimeout(() => {
+        if (this.sockets.get(id) !== socket || socket.state !== 0) return;
+        this.terminate(id, socket, 1006, "", "Virtual WebSocket connection timed out.");
+      }, OPEN_TIMEOUT_MS)
+    };
+    this.sockets.set(id, socket);
+    const endpoint = this.registry?.endpoint(port);
+    const bridge = endpoint ? (next) => endpoint.open(path, [...protocols], next) : this.connector ? (next) => this.connector.open(port, path, [...protocols], next, validAuthority(addressed?.host) ? { host: addressed.host } : void 0) : void 0;
+    if (!bridge) {
+      clearTimeout(socket.timeout);
+      this.sockets.delete(id);
+      throw new Error("The virtual WebSocket port has no engine connector.");
+    }
+    try {
+      const connection = bridge({
+        open: (protocol) => {
+          if (this.sockets.get(id) !== socket || socket.state !== 0) return;
+          if (typeof protocol !== "string" || protocol !== "" && !protocols.includes(protocol)) {
+            this.terminate(id, socket, 1006, "", "The virtual server selected an unrequested WebSocket protocol.");
+            return;
+          }
+          clearTimeout(socket.timeout);
+          socket.timeout = void 0;
+          socket.state = 1;
+          this.notify(() => handlers.open(protocol));
+        },
+        message: (data) => {
+          if (this.sockets.get(id) !== socket || socket.state !== 1) return;
+          try {
+            assertFrameSize(data);
+          } catch (cause) {
+            this.terminate(id, socket, 1009, "Invalid server frame", cause instanceof Error ? cause.message : String(cause));
+            return;
+          }
+          this.notify(() => handlers.message(data));
+        },
+        close: (code, reason, clean) => {
+          if (!this.retire(id, socket)) return;
+          this.notify(() => handlers.close(code, reason, clean));
+        },
+        error: (message) => {
+          if (this.sockets.get(id) === socket) this.terminate(id, socket, 1006, "", message);
+        }
+      });
+      socket.connection = connection;
+      if (this.sockets.get(id) !== socket) this.abortConnection(socket);
+      else if (socket.closing) this.requestClose(id, socket);
+    } catch (cause) {
+      this.retire(id, socket);
+      this.abortConnection(socket);
+      throw cause;
+    }
+  }
+  send(id, data) {
+    const socket = this.sockets.get(id);
+    if (!socket || socket.state !== 1 || !socket.connection) throw new Error("Virtual WebSocket is not open.");
+    assertFrameSize(data);
+    try {
+      socket.connection.send(data);
+    } catch (cause) {
+      this.terminate(id, socket, 1006, "", cause instanceof Error ? cause.message : String(cause));
+      throw cause;
+    }
+  }
+  close(id, code = 1e3, reason = "") {
+    const socket = this.sockets.get(id);
+    if (!socket) return;
+    assertClose(code, reason);
+    if (socket.state >= 2) return;
+    socket.state = 2;
+    socket.closing = { code, reason };
+    clearTimeout(socket.timeout);
+    socket.timeout = void 0;
+    socket.closeTimer = setTimeout(() => {
+      if (this.sockets.get(id) !== socket) return;
+      this.terminate(id, socket, 1006, "");
+    }, 100);
+    this.requestClose(id, socket);
+  }
+  /** Host-side cancellation; it does not claim a completed close handshake. */
+  abort(id, code = 1006, reason = "") {
+    const socket = this.sockets.get(id);
+    if (socket) this.terminate(id, socket, code, reason);
+  }
+  closeAll() {
+    if (this.closingAll) return;
+    this.closingAll = true;
+    try {
+      for (const [id, socket] of [...this.sockets]) this.terminate(id, socket, 1001, "Connection owner closed");
+    } finally {
+      this.closingAll = false;
+    }
+  }
+  closePort(port) {
+    for (const [id, socket] of [...this.sockets]) {
+      if (socket.port === port) this.terminate(id, socket, 1001, "Virtual server stopped");
+    }
+  }
+  requestClose(id, socket) {
+    if (!socket.connection || !socket.closing) return;
+    try {
+      socket.connection.close(socket.closing.code, socket.closing.reason);
+    } catch (cause) {
+      this.terminate(id, socket, 1006, "", cause instanceof Error ? cause.message : String(cause));
+    }
+  }
+  retire(id, socket) {
+    if (this.sockets.get(id) !== socket) return false;
+    this.sockets.delete(id);
+    socket.state = 3;
+    clearTimeout(socket.timeout);
+    clearTimeout(socket.closeTimer);
+    socket.timeout = void 0;
+    socket.closeTimer = void 0;
+    return true;
+  }
+  terminate(id, socket, code, reason, error) {
+    if (!this.retire(id, socket)) return;
+    this.abortConnection(socket);
+    if (error !== void 0) this.notify(() => socket.handlers.error(error));
+    this.notify(() => socket.handlers.close(code, reason, false));
+  }
+  abortConnection(socket) {
+    const connection = socket.connection;
+    socket.connection = void 0;
+    if (!connection) return;
+    try {
+      if (connection.abort) connection.abort();
+      else connection.close(1e3, "Connection cancelled");
+    } catch (cause) {
+      console.error("Virtual WebSocket transport cleanup failed.", cause);
+    }
+  }
+  notify(callback) {
+    try {
+      callback();
+    } catch (cause) {
+      console.error("Virtual WebSocket observer failed.", cause);
+    }
+  }
+};
+function assertPort(port) {
+  if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error("Invalid virtual WebSocket port.");
+}
+function validPath(path) {
+  if (typeof path !== "string") return false;
+  if (!path.startsWith("/") || path.startsWith("//") || path.length > 16384 || /[\\\u0000-\u001f\u007f]/u.test(path)) return false;
+  try {
+    return new URL(path, "https://virtual.invalid").origin === "https://virtual.invalid";
+  } catch {
+    return false;
+  }
+}
+function validProtocol(protocol) {
+  return protocol.length > 0 && protocol.length <= 128 && /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/u.test(protocol);
+}
+function assertFrameSize(data) {
+  if (!data || typeof data !== "object" || data.kind !== "text" && data.kind !== "binary" || (data.kind === "text" ? typeof data.text !== "string" : !("bytes" in data ? data.bytes instanceof Uint8Array : typeof data.base64 === "string"))) {
+    throw new Error("Invalid virtual WebSocket frame.");
+  }
+  if (data.kind === "binary" && !("bytes" in data) && data.base64.length > Math.ceil(MAX_VIRTUAL_WEBSOCKET_FRAME_BYTES / 3) * 4) {
+    throw new Error("Virtual WebSocket frame exceeds 32 MiB.");
+  }
+  const size = data.kind === "text" ? new TextEncoder().encode(data.text).byteLength : virtualFrameByteLength(data);
+  if (size === void 0) throw new Error("Invalid virtual WebSocket binary frame.");
+  if (size > MAX_VIRTUAL_WEBSOCKET_FRAME_BYTES) throw new Error("Virtual WebSocket frame exceeds 32 MiB.");
+}
+function assertClose(code, reason) {
+  if (!Number.isSafeInteger(code) || code !== 1e3 && (code < 3e3 || code > 4999)) {
+    throw new Error("Invalid virtual WebSocket close code.");
+  }
+  if (typeof reason !== "string" || new TextEncoder().encode(reason).byteLength > 123) throw new Error("Virtual WebSocket close reason is invalid or too long.");
+}
+function validAuthority(value) {
+  return typeof value === "string" && value.length <= 255 && /^(?:\[[0-9a-f:.]+\]|[a-z0-9.-]+)(?::[0-9]{1,5})?$/iu.test(value);
+}
+
+// packages/runtime/src/browser-http.ts
+var observedBridges = /* @__PURE__ */ new WeakMap();
+function observeBrowserServerPorts(bridge, listener) {
+  let observed = observedBridges.get(bridge);
+  if (!observed) {
+    observed = { listeners: /* @__PURE__ */ new Set(), registrations: /* @__PURE__ */ new Map() };
+    observedBridges.set(bridge, observed);
+    const register = bridge.registerServer.bind(bridge);
+    const unregister = bridge.unregisterServer.bind(bridge);
+    bridge.registerServer = (server, port, hostname) => {
+      const existed = bridge.getServerPorts().includes(port);
+      const handle = server.handleRequest.bind(server);
+      server.handleRequest = (method, url, headers, body) => {
+        const named = Object.keys(headers).some((name) => name.toLowerCase() === "host");
+        return handle(method, url, named ? headers : { ...headers, host: `${hostname && hostname !== "0.0.0.0" && hostname !== "::" ? hostname : "127.0.0.1"}:${port}` }, body);
+      };
+      register(server, port, hostname);
+      observed.registrations.set(port, { server });
+      if (!existed) {
+        const event = {
+          port,
+          type: "open",
+          ...bridge.getServerUrl ? { url: bridge.getServerUrl(port) } : {}
+        };
+        for (const accept of observed.listeners) {
+          try {
+            accept(event);
+          } catch (cause) {
+            console.error("Port registration observer failed.", cause);
+          }
+        }
+      }
+    };
+    bridge.unregisterServer = (port) => {
+      const existed = bridge.getServerPorts().includes(port);
+      unregister(port);
+      observed.registrations.delete(port);
+      if (existed) {
+        const event = { port, type: "close" };
+        for (const accept of observed.listeners) {
+          try {
+            accept(event);
+          } catch (cause) {
+            console.error("Port release observer failed.", cause);
+          }
+        }
+      }
+    };
+  }
+  observed.listeners.add(listener);
+  return () => observed.listeners.delete(listener);
+}
+
+// packages/runtime/src/browser-pack-index.ts
+var encoder3 = new TextEncoder();
+var decoder = new TextDecoder();
+
+// packages/runtime/src/browser-pack-store.ts
+var encoder4 = new TextEncoder();
+var decoder2 = new TextDecoder("utf-8", { fatal: true });
+var MAX_RECORD_BYTES = 64 * 1024 * 1024;
+var MAX_FILE_BYTES = 1024 * 1024 * 1024;
+var MAX_LOG_BYTES = 8 * 1024 * 1024;
+var COMPACTION_FLOOR_BYTES = 64 * 1024 * 1024;
+var SESSION_COMPACTION_BYTES = 256 * 1024 * 1024;
+var COPY_BUFFER_BYTES = 4 * 1024 * 1024;
+var SWEEP_COMPACTION_BYTES = 64 * 1024 * 1024;
+var SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var SWEEP_GRACE_MS = 14 * 24 * 60 * 60 * 1e3;
+
+// packages/runtime/src/browser-project-store.ts
+var MAX_PROJECT_BYTES = 1024 * 1024 * 1024;
+var writeTail = Promise.resolve();
+
+// packages/runtime/src/http-transport-policy.ts
+var MAX_HTTP_TRANSPORT_POLICY_BYTES = 1024 * 1024;
+
+// packages/runtime/src/browser-runtime-policy.ts
+var DEFAULT_BROWSER_RUNTIME_LIMITS = Object.freeze({
+  maxConcurrentProcesses: 64,
+  maxProcessOutputBytes: 16 * 1024 * 1024,
+  maxProcessRuntimeMs: 0,
+  maxVirtualPorts: 64,
+  maxFilesystemEntries: 1e6,
+  maxFilesystemBytes: 1024 * 1024 * 1024,
+  maxVirtualRequests: 32,
+  maxVirtualWebSockets: 32,
+  maxVirtualRequestBytes: 16 * 1024 * 1024,
+  maxVirtualResponseBytes: 32 * 1024 * 1024,
+  maxPreviewCommands: 16,
+  maxPreviewObservations: 1e3,
+  maxEgressConnections: 16,
+  maxEgressBytes: 64 * 1024 * 1024
+});
+
+// packages/runtime/src/browser-preview-sockets.ts
+var BrowserPreviewSocketRelay = class {
+  constructor(hub, send, limits = DEFAULT_BROWSER_RUNTIME_LIMITS) {
+    this.hub = hub;
+    this.send = send;
+    this.limits = limits;
+  }
+  hub;
+  send;
+  limits;
+  active = /* @__PURE__ */ new Set();
+  get openSockets() {
+    return this.active.size;
+  }
+  async handle(message) {
+    if (!message || typeof message !== "object" || Array.isArray(message)) {
+      throw new Error("Malformed virtual WebSocket message.");
+    }
+    const request = message;
+    if (!Number.isSafeInteger(request.id) || request.id < 1 || !request.data) {
+      throw new Error("Invalid virtual WebSocket message.");
+    }
+    const id = request.id;
+    if (request.type === "websocket-open") {
+      if (this.active.size >= this.limits.maxVirtualWebSockets) {
+        throw new Error("Virtual WebSocket concurrency exceeded.");
+      }
+      if (this.active.has(id)) throw new Error("Duplicate virtual WebSocket identifier.");
+      this.active.add(id);
+      try {
+        this.hub.open(
+          id,
+          request.data.port,
+          request.data.path,
+          request.data.protocols ?? [],
+          {
+            open: (protocol) => this.send({ type: "websocket-open", id, data: { protocol } }),
+            message: (frame2) => this.send({ type: "websocket-message", id, data: { frame: frame2 } }),
+            close: (code, reason, clean) => {
+              this.active.delete(id);
+              this.send({ type: "websocket-close", id, data: { code, reason, clean } });
+            },
+            error: (error) => this.send({ type: "websocket-error", id, error })
+          },
+          typeof request.data.host === "string" ? { host: request.data.host } : void 0
+        );
+      } catch (cause) {
+        this.active.delete(id);
+        throw cause;
+      }
+      return;
+    }
+    if (!this.active.has(id)) throw new Error("Unknown virtual WebSocket identifier.");
+    if (request.type === "websocket-message") {
+      if (!request.data.frame) throw new Error("Virtual WebSocket message has no frame.");
+      this.hub.send(id, request.data.frame);
+      return;
+    }
+    if (request.type === "websocket-close") {
+      this.hub.close(id, request.data.code, request.data.reason);
+      this.active.delete(id);
+      return;
+    }
+    throw new Error("Unknown virtual WebSocket operation.");
+  }
+  closeAll() {
+    for (const id of [...this.active]) {
+      try {
+        this.hub.close(id, 1001, "The preview went away.");
+      } catch {
+      }
+      this.active.delete(id);
+    }
+  }
+};
+function websocketRequestType(message) {
+  const type = message?.type;
+  return typeof type === "string" && type.startsWith("websocket-");
+}
+
+// packages/runtime/src/browser-operation.ts
+async function waitForBrowserOperation(operation, signal) {
+  const running = typeof operation === "function" ? Promise.resolve().then(() => {
+    signal.throwIfAborted();
+    return operation();
+  }) : Promise.resolve(operation);
+  let abort;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => reject(signal.reason ?? new DOMException("Browser operation was cancelled.", "AbortError"));
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+  try {
+    return await Promise.race([running, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+// packages/runtime/src/browser-cookie-jar.ts
+var MAX_LIFETIME_MS = 400 * 24 * 60 * 60 * 1e3;
+var BROWSER_COOKIE_JAR_GLOBAL = "__browserRuntimeCookies";
+
+// packages/runtime/src/browser-host-fetch.ts
+var HOST_FETCH_MAX_CHUNK_BYTES = 65536;
+var HOST_FETCH_DEFAULT_MAX_REQUEST_BYTES = 16 * 1024 * 1024;
+
+// packages/runtime/src/browser-sandbox-bridge.ts
+var MAX_REQUEST_URL_CHARS = 16384;
+var MAX_REQUEST_HEADERS = 128;
+var MAX_REQUEST_HEADER_CHARS = 65536;
+var SANDBOX_HANDSHAKE_TIMEOUT_MS = 15e3;
+var SANDBOX_COMMAND_TIMEOUT_MS = 15e3;
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]);
+var HTTP_HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+function validateSandboxRequest(message, isRegisteredPort, limits = DEFAULT_BROWSER_RUNTIME_LIMITS) {
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error("Malformed sandbox service-worker message.");
+  }
+  const request = message;
+  const data = request.data;
+  if (request.type !== "request" || !Number.isSafeInteger(request.id) || !data || !Number.isSafeInteger(data.port)) {
+    throw new Error("Rejected an invalid virtual-server request.");
+  }
+  if (!isRegisteredPort(data.port)) throw new Error(`Virtual port ${data.port} is not listening.`);
+  const registeredPort = data.port;
+  if (!data.method || !HTTP_METHODS.has(data.method) || !data.url || data.url.length > MAX_REQUEST_URL_CHARS || !data.url.startsWith("/") || data.url.startsWith("//") || /[\\\u0000-\u001f\u007f]/u.test(data.url)) {
+    throw new Error("Rejected an invalid virtual-server request target.");
+  }
+  const parsed = new URL(data.url, "https://virtual.invalid");
+  if (parsed.origin !== "https://virtual.invalid") throw new Error("Rejected a cross-origin virtual-server request.");
+  if (!data.headers || typeof data.headers !== "object" || Array.isArray(data.headers)) {
+    throw new Error("Rejected invalid virtual-server request headers.");
+  }
+  const headerEntries = Object.entries(data.headers);
+  if (headerEntries.length > MAX_REQUEST_HEADERS) throw new Error("Virtual-server request has too many headers.");
+  let headerChars = 0;
+  for (const [name, value] of headerEntries) {
+    if (!HTTP_HEADER_NAME.test(name) || typeof value !== "string" || /[\u0000\r\n]/u.test(value)) {
+      throw new Error("Rejected malformed virtual-server request headers.");
+    }
+    headerChars += name.length + value.length;
+  }
+  if (headerChars > MAX_REQUEST_HEADER_CHARS) throw new Error("Virtual-server request headers are too large.");
+  if (data.body !== void 0 && data.body !== null && !(data.body instanceof ArrayBuffer)) {
+    throw new Error("Rejected an invalid virtual-server request body.");
+  }
+  if (data.body && data.body.byteLength > limits.maxVirtualRequestBytes) {
+    throw new Error(`Virtual-server request body exceeds ${limits.maxVirtualRequestBytes} bytes.`);
+  }
+  if (data.streaming !== void 0 && typeof data.streaming !== "boolean") throw new Error("Rejected an invalid virtual-server streaming flag.");
+  if (data.flowControl !== void 0 && data.flowControl !== 1) throw new Error("Rejected an unsupported virtual-server flow-control protocol.");
+  return {
+    id: request.id,
+    data: {
+      port: registeredPort,
+      method: data.method,
+      url: data.url,
+      headers: data.headers,
+      ...data.body ? { body: data.body } : {},
+      streaming: data.streaming === true,
+      flowControl: data.flowControl === 1
+    }
+  };
+}
+function responseHeader(headers, name) {
+  const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase());
+  const value = entry?.[1];
+  return Array.isArray(value) ? value[0] : value;
+}
+function rewriteHtmlModules(body, headers, rewrites) {
+  if (!responseHeader(headers, "content-type")?.toLowerCase().includes("text/html")) return body;
+  let html = new TextDecoder().decode(body);
+  for (const [remote, local] of Object.entries(rewrites ?? {})) html = html.replaceAll(remote, local);
+  html = injectBrowserLoopback(html);
+  return new TextEncoder().encode(html);
+}
+var LOOPBACK_BOOTSTRAP_MARKER = "data-browser-runtime-loopback";
+var VIRTUAL_HOST_PARAMETER = "__browser_runtime_virtual_host";
+function injectBrowserLoopback(html) {
+  if (html.includes(LOOPBACK_BOOTSTRAP_MARKER)) return html;
+  const script = `<script ${LOOPBACK_BOOTSTRAP_MARKER}>(function(){
+const clip=function(value,limit){return String(value===undefined?'undefined':value===null?'null':value instanceof Error?(value.stack||value.message):typeof value==='object'?function(){try{return JSON.stringify(value);}catch{return Object.prototype.toString.call(value);}}():value).slice(0,limit);};
+const observations=[];
+Object.defineProperty(window,'__browserRuntimePreviewObservations',{value:function(){return observations.slice();}});
+const report=function(observation){try{observations.push(observation);if(observations.length>200)observations.shift();window.dispatchEvent(new CustomEvent('browser-runtime-preview-observation',{detail:observation}));window.parent.postMessage({type:'browser-agent-observation',observation:observation},location.origin);}catch{}};
+const notifyPreviewLoad=function(){
+  window.parent.postMessage({type:'browser-agent-preview-load'},location.origin);
+  report({kind:'navigation',url:location.href,title:document.title.slice(0,4096),timestamp:Date.now()});
+};
+if(document.readyState==='loading')document.addEventListener('DOMContentLoaded',notifyPreviewLoad,{once:true});else queueMicrotask(notifyPreviewLoad);
+['debug','info','log','warn','error'].forEach(function(level){
+  const original=console[level].bind(console);
+  console[level]=function(){const args=Array.prototype.slice.call(arguments);original.apply(console,args);report({kind:'console',level:level,message:args.map(function(value){return clip(value,8192);}).join(' ').slice(0,32768),timestamp:Date.now()});};
+});
+window.addEventListener('error',function(event){report({kind:'exception',message:clip(event.message||event.error,32768),stack:event.error?.stack?clip(event.error.stack,65536):undefined,source:event.filename?clip(event.filename,16384):undefined,line:Number.isSafeInteger(event.lineno)?event.lineno:undefined,column:Number.isSafeInteger(event.colno)?event.colno:undefined,timestamp:Date.now()});});
+window.addEventListener('unhandledrejection',function(event){const reason=event.reason;report({kind:'unhandledrejection',message:clip(reason,32768),stack:reason?.stack?clip(reason.stack,65536):undefined,timestamp:Date.now()});});
+const networkState=window.__browserRuntimeNetworkState={pending:0,lastChanged:Date.now()};
+const networkBegin=function(){networkState.pending++;networkState.lastChanged=Date.now();};
+const networkEnd=function(){networkState.pending=Math.max(0,networkState.pending-1);networkState.lastChanged=Date.now();};
+const nativeFetch=window.fetch.bind(window);
+const virtualHostParameter=${JSON.stringify(VIRTUAL_HOST_PARAMETER)};
+const route=function(value){
+  try {
+    const url=new URL(String(value),location.href);
+    if(url.protocol!=='http:'&&url.protocol!=='https:')return value;
+    // a root-relative URL from inside a virtual document is the document's
+    // own server's: the page under /__virtual__/<port>/ is that server's
+    // root, so /api/x is its /api/x. The service worker routed these by the
+    // request's referrer, which a document sent with no referrer never has.
+    if(url.origin===location.origin){
+      const own=/^[/]__virtual__[/]([0-9]+)(?=[/]|$)/.exec(location.pathname)||(function(){try{return /^[/]__virtual__[/]([0-9]+)(?=[/]|$)/.exec(window.parent.location.pathname);}catch(e){return null;}})();
+      if(!own||url.pathname.startsWith('/__virtual__/')) return value;
+      const routed=new URL(location.origin+'/__virtual__/'+own[1]+url.pathname+url.search);
+      // The host this document is answered as is the session's, not this one
+      // URL's: a page that answers as one host asked for its own assets as
+      // another, and the server sent them down a different route entirely.
+      const carried=new URLSearchParams(location.search).get(virtualHostParameter);
+      if(carried&&!routed.searchParams.has(virtualHostParameter))routed.searchParams.set(virtualHostParameter,carried);
+      routed.hash=url.hash;
+      return routed.href;
+    }
+    const loopback=url.hostname==='localhost'||url.hostname.endsWith('.localhost')||url.hostname==='127.0.0.1'||url.hostname==='[::1]';
+    if((url.protocol==='http:'||url.protocol==='https:')&&loopback){
+      const port=url.port||String(url.protocol==='https:'?443:80);
+      const routed=new URL(location.origin+'/__virtual__/'+port+url.pathname+url.search);
+      routed.searchParams.set(virtualHostParameter,url.host);
+      routed.hash=url.hash;
+      return routed.href;
+    }
+  } catch {}
+  return value;
+};
+// document.cookie is the tab's jar (ADR-0050): the host's cookies live there,
+// not in this origin's, and a server here set them through its answers. The
+// jar is offered by a same-origin ancestor, the page that holds the tab; a
+// frame of another origin cannot read it, and keeps the browser's own.
+(function(){
+  let cookies=null;
+  try{for(let owner=window.parent;;owner=owner.parent){const offered=owner[${JSON.stringify(BROWSER_COOKIE_JAR_GLOBAL)}];if(offered&&typeof offered.read==='function'){cookies=offered;break;}if(owner===owner.parent)break;}}catch{}
+  if(!cookies)return;
+  const where=function(){
+    const host=new URLSearchParams(location.search).get(virtualHostParameter)||location.host;
+    const path=location.pathname.replace(/^[/]__virtual__[/][0-9]+(?=[/]|$)/,'')||'/';
+    return {host:host,path:path};
+  };
+  Object.defineProperty(document,'cookie',{configurable:true,enumerable:true,get:function(){return cookies.read(where());},set:function(value){cookies.write(where(),String(value));}});
+})();
+window.fetch=function(input,init){
+  if(input instanceof Request){
+    const target=route(input.url);
+    networkBegin();
+    try{return nativeFetch(target===input.url?input:new Request(target,input),init).finally(networkEnd);}catch(error){networkEnd();throw error;}
+  }
+  networkBegin();
+  try{return nativeFetch(route(input),init).finally(networkEnd);}catch(error){networkEnd();throw error;}
+};
+const nativeOpen=XMLHttpRequest.prototype.open;
+XMLHttpRequest.prototype.open=function(method,url){
+  const args=Array.prototype.slice.call(arguments);
+  args[1]=route(url);
+  return nativeOpen.apply(this,args);
+};
+const nativeSend=XMLHttpRequest.prototype.send;
+XMLHttpRequest.prototype.send=function(){networkBegin();this.addEventListener('loadend',networkEnd,{once:true});try{return nativeSend.apply(this,arguments);}catch(error){networkEnd();throw error;}};
+// A beacon is a request too: vgai's editor sends its heartbeat with one, and
+// a root-relative beacon that is not routed reaches the page's origin, which
+// answers 405 once a second.
+if(typeof navigator.sendBeacon==='function'){
+  const nativeSendBeacon=navigator.sendBeacon.bind(navigator);
+  navigator.sendBeacon=function(url,data){return data===undefined?nativeSendBeacon(route(url)):nativeSendBeacon(route(url),data);};
+}
+// A worker a virtual document makes is that document's server's: its script
+// URL routed like any request, so the worker's own requests carry a referrer
+// that names the port and the service worker attributes them. Made from the
+// origin root, a worker's root-relative fetch reached the page's origin.
+// A blob has no script fetch carrying the virtual path. Keep its creator
+// identity for the service worker to query, including after SW restarts.
+// Keep URL names after revoke: an already-running worker still uses that URL.
+const createdObjectUrls=new Set();
+const nativeCreateObjectURL=URL.createObjectURL.bind(URL);
+URL.createObjectURL=function(value){const url=nativeCreateObjectURL(value);createdObjectUrls.add(url);return url;};
+if(navigator.serviceWorker)navigator.serviceWorker.addEventListener('message',function(event){
+  if(event.data?.type!=='virtual-blob-owner'||!event.ports[0])return;
+  const url=String(event.data.url||'').split('#')[0];
+  event.ports[0].postMessage(createdObjectUrls.has(url));
+  event.ports[0].close();
+});
+for(const name of ['Worker','SharedWorker']){
+  const Native=window[name];
+  if(typeof Native!=='function')continue;
+  const Routed=function(url,options){return options===undefined?new Native(route(url)):new Native(route(url),options);};
+  Routed.prototype=Native.prototype;
+  window[name]=Routed;
+}
+if(typeof EventSource==='function'){
+  const NativeEventSource=EventSource;
+  window.EventSource=function(url,options){return new NativeEventSource(route(url),options);};
+  window.EventSource.prototype=NativeEventSource.prototype;
+  Object.defineProperties(window.EventSource,{CONNECTING:{value:0},OPEN:{value:1},CLOSED:{value:2}});
+}
+const NativeWebSocket=window.WebSocket;
+let virtualWebSocketSequence=0;
+// A document numbers its sockets from a base of its own: the document before
+// it in the frame may still hold sockets the host has not finished, and a
+// number shared with one of those is refused as a duplicate.
+const virtualWebSocketBase=Math.floor(Math.random()*2147483648)*1048576;
+const virtualWebSockets=new Map();
+const ownBytes=function(value){
+  const view=value instanceof ArrayBuffer?new Uint8Array(value):new Uint8Array(value.buffer,value.byteOffset,value.byteLength);
+  return view.slice();
+};
+const decodeBinary=function(value){
+  if(typeof Uint8Array.fromBase64==='function')return Uint8Array.fromBase64(value);
+  const binary=atob(value);
+  const out=new Uint8Array(binary.length);
+  for(let index=0;index<binary.length;index+=1)out[index]=binary.charCodeAt(index);
+  return out;
+};
+const emitSocket=function(socket,type,event){
+  socket.dispatchEvent(event);
+  const handler=socket['on'+type];
+  if(typeof handler==='function')handler.call(socket,event);
+};
+class VirtualWebSocket extends EventTarget{
+  constructor(url,protocols){
+    super();
+    const parsed=new URL(String(url),location.href);
+    this.url=parsed.href;
+    this.readyState=0;
+    this.bufferedAmount=0;
+    this.extensions='';
+    this.protocol='';
+    this.binaryType='blob';
+    this.onopen=this.onmessage=this.onerror=this.onclose=null;
+    this.__id=virtualWebSocketBase+(++virtualWebSocketSequence);
+    virtualWebSockets.set(this.__id,this);
+    // A socket to the page's own host from a frame served under a virtual
+    // port is a socket to that port: a dev server's HMR client computes its
+    // URL from location, which names the page's origin, not the server's.
+    // A document at the origin's root has no prefix to name its server: 0
+    // says its own, and the sandbox that opened it fills the port in.
+    const virtualMatch=/^[/]__virtual__[/]([0-9]+)(?=[/]|$)/.exec(location.pathname);
+    const ownHost=parsed.host===location.host||(parsed.hostname===location.hostname&&parsed.port==='');
+    const port=ownHost?(virtualMatch?Number(virtualMatch[1]):0):Number(parsed.port||((parsed.protocol==='wss:')?443:80));
+    const selected=protocols===undefined?[]:(Array.isArray(protocols)?protocols:[protocols]);
+    window.parent.postMessage({type:'websocket-open',id:this.__id,data:{port:port,host:parsed.host,path:parsed.pathname+parsed.search,protocols:selected.map(String)}},location.origin);
+  }
+  send(value){
+    if(this.readyState!==1)throw new DOMException('WebSocket is not open.','InvalidStateError');
+    if(value instanceof Blob){
+      this.bufferedAmount+=value.size;
+      void value.arrayBuffer().then((buffer)=>{this.bufferedAmount=Math.max(0,this.bufferedAmount-value.size);this.__send({kind:'binary',bytes:new Uint8Array(buffer)});});
+      return;
+    }
+    // Bytes cross to the page as they are (a copy the socket owns), not as base64.
+    const frame=typeof value==='string'?{kind:'text',text:value}:{kind:'binary',bytes:ownBytes(value)};
+    this.__send(frame);
+  }
+  __send(frame){window.parent.postMessage({type:'websocket-message',id:this.__id,data:{frame:frame}},location.origin);}
+  close(code,reason){
+    if(this.readyState===2||this.readyState===3)return;
+    this.readyState=2;
+    window.parent.postMessage({type:'websocket-close',id:this.__id,data:{code:code===undefined?1000:code,reason:reason===undefined?'':String(reason)}},location.origin);
+  }
+}
+Object.defineProperties(VirtualWebSocket,{CONNECTING:{value:0},OPEN:{value:1},CLOSING:{value:2},CLOSED:{value:3}});
+Object.defineProperties(VirtualWebSocket.prototype,{CONNECTING:{value:0},OPEN:{value:1},CLOSING:{value:2},CLOSED:{value:3}});
+window.addEventListener('message',function(event){
+  if(event.source!==window.parent||event.origin!==location.origin||typeof event.data?.type!=='string'||!event.data.type.startsWith('websocket-'))return;
+  const message=event.data;
+  const socket=virtualWebSockets.get(message.id);
+  if(!socket)return;
+  if(message.type==='websocket-open'){
+    socket.readyState=1;
+    socket.protocol=String(message.data?.protocol||'');
+    emitSocket(socket,'open',new Event('open'));
+  }else if(message.type==='websocket-message'){
+    const frame=message.data?.frame;
+    let data=frame?.kind==='text'?String(frame.text):(frame?.bytes instanceof Uint8Array?frame.bytes:decodeBinary(String(frame?.base64||'')));
+    if(data instanceof Uint8Array&&(data.byteOffset!==0||data.byteLength!==data.buffer.byteLength))data=data.slice();
+    if(frame?.kind==='binary')data=socket.binaryType==='arraybuffer'?data.buffer:new Blob([data]);
+    emitSocket(socket,'message',new MessageEvent('message',{data:data}));
+  }else if(message.type==='websocket-close'){
+    socket.readyState=3;
+    virtualWebSockets.delete(message.id);
+    emitSocket(socket,'close',new CloseEvent('close',{code:message.data?.code||1000,reason:String(message.data?.reason||''),wasClean:message.data?.clean!==false}));
+  }else if(message.type==='websocket-error'){
+    emitSocket(socket,'error',new ErrorEvent('error',{message:String(message.error||'Virtual WebSocket failed.')}));
+    if(socket.readyState!==3){
+      socket.readyState=3;
+      virtualWebSockets.delete(message.id);
+      emitSocket(socket,'close',new CloseEvent('close',{code:1006,reason:'',wasClean:false}));
+    }
+  }
+});
+// A document leaving the frame takes its sockets with it, as a browser
+// closes a page's sockets; the next document starts its numbering over.
+window.addEventListener('pagehide',function(){
+  virtualWebSockets.forEach(function(socket){
+    if(socket.readyState===0||socket.readyState===1)socket.close(1001,'Page hidden');
+  });
+});
+window.WebSocket=function(url,protocols){
+  const parsed=new URL(String(url),location.href);
+  const local=(parsed.protocol==='ws:'||parsed.protocol==='wss:')&&(parsed.host===location.host||parsed.hostname==='localhost'||parsed.hostname.endsWith('.localhost')||parsed.hostname==='127.0.0.1'||parsed.hostname==='[::1]');
+  // The host answers from the frame's parent. A document with no parent (the
+  // app opened by its share link, a preview in a tab of its own) has no host
+  // to answer: its messages would come back to itself, every frame an echo,
+  // and its sockets go out as the browser's own.
+  if(local&&window.parent!==window)return new VirtualWebSocket(parsed.href,protocols);
+  return protocols===undefined?new NativeWebSocket(parsed.href):new NativeWebSocket(parsed.href,protocols);
+};
+window.WebSocket.prototype=VirtualWebSocket.prototype;
+Object.defineProperties(window.WebSocket,{CONNECTING:{value:0},OPEN:{value:1},CLOSING:{value:2},CLOSED:{value:3}});
+})();<\/script>`;
+  if (/<head(?:\s[^>]*)?>/iu.test(html)) return html.replace(/<head(?:\s[^>]*)?>/iu, (head) => `${head}
+${script}`);
+  return `${script}
+${html}`;
+}
+var BrowserSandboxBridge = class {
+  constructor(options) {
+    this.options = options;
+    this.port = options.port;
+    this.ready = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.initialPreviewReady = new Promise((resolve, reject) => {
+      this.resolveInitialPreview = resolve;
+      this.rejectInitialPreview = reject;
+    });
+    void this.ready.catch(() => {
+    });
+    void this.initialPreviewReady.catch(() => {
+    });
+    this.webSockets = new BrowserVirtualWebSocketHub(
+      (port) => this.options.bridge.getServerPorts().includes(port),
+      this.options.webSocketRegistry,
+      this.options.webSocketConnector
+    );
+    this.socketRelay = new BrowserPreviewSocketRelay(this.webSockets, (message) => this.send(message), this.limits);
+    this.stopObservingPorts = observeBrowserServerPorts(this.options.bridge, (event) => {
+      if (event.type === "close") {
+        this.webSockets.closePort(event.port);
+        for (const request of this.requestControllers.values()) {
+          if (request.port === event.port) request.controller.abort(new Error("The preview server stopped."));
+        }
+      }
+    });
+    this.stopObservingHostServices = options.hostFetchServices?.observe((port, capability) => {
+      if (!this.bridgeConnected) return;
+      this.send(capability ? { type: "server-registered", data: { port, hostname: "127.0.0.1", ...capability } } : this.options.bridge.getServerPorts().includes(port) ? { type: "server-registered", data: { port, hostname: "127.0.0.1" } } : { type: "server-unregistered", data: { port } });
+    }) ?? (() => void 0);
+    window.addEventListener("message", this.onMessage);
+  }
+  options;
+  ready;
+  initialPreviewReady;
+  resolveReady;
+  rejectReady;
+  resolveInitialPreview;
+  rejectInitialPreview;
+  activeRequestIds = /* @__PURE__ */ new Set();
+  /** Requests past the concurrency limit, each released as a slot frees. */
+  waitingRequests = [];
+  activeWebSocketIds = /* @__PURE__ */ new Set();
+  activeCommands = /* @__PURE__ */ new Map();
+  observationBuffer = [];
+  webSockets;
+  socketRelay;
+  stopObservingPorts;
+  requestControllers = /* @__PURE__ */ new Map();
+  hostFlowRequests = /* @__PURE__ */ new Map();
+  stopObservingHostServices;
+  readyTimer;
+  initialPreviewTimer;
+  readyFinished = false;
+  initialPreviewFinished = false;
+  bridgeConnected = false;
+  previewConnected = false;
+  announcedReady = false;
+  readinessWaiters = /* @__PURE__ */ new Set();
+  disposed = false;
+  nextCommandId = 1;
+  protocolChannel;
+  cancelProtocolAttachment;
+  protocolDocumentId;
+  port;
+  /** A bounded observation of current readiness; a timeout does not poison later observations. */
+  waitForReady(timeoutMs = SANDBOX_HANDSHAKE_TIMEOUT_MS) {
+    this.assertActive();
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Invalid sandbox readiness timeout.");
+    if (this.bridgeConnected && this.previewConnected) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const finish = (error) => {
+        globalThis.clearTimeout(timer);
+        this.readinessWaiters.delete(waiter);
+        if (error) reject(error);
+        else resolve();
+      };
+      const waiter = { resolve: () => finish(), reject: (error) => finish(error) };
+      const timer = globalThis.setTimeout(() => finish(new Error("Sandbox preview connection timed out.")), timeoutMs);
+      this.readinessWaiters.add(waiter);
+    });
+  }
+  setPort(port) {
+    this.assertActive();
+    if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error("Invalid virtual server port.");
+    this.port = port;
+    this.armStartupTimeouts();
+  }
+  snapshot() {
+    return this.command({ operation: "snapshot" });
+  }
+  query(selector) {
+    return this.command({ operation: "query", selector });
+  }
+  screenshot(options = {}) {
+    return this.command({ operation: "screenshot", ...options });
+  }
+  navigate(url) {
+    return this.command({ operation: "navigate", url });
+  }
+  reloadPreview() {
+    return this.command({ operation: "reload" });
+  }
+  waitForNetworkIdle(options = {}) {
+    return this.command({
+      operation: "network-idle",
+      ...options.idleMs !== void 0 ? { idleMs: options.idleMs } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
+    }, (options.timeoutMs ?? 1e4) + 1e3);
+  }
+  setPreviewScript(source) {
+    return this.command({ operation: "set-script", ...source !== void 0 ? { source } : {} });
+  }
+  /** Execute trusted host instrumentation in the app's realm, returning JSON. */
+  evaluatePreview(source, args) {
+    return this.command({ operation: "evaluate", source, ...args !== void 0 ? { args } : {} });
+  }
+  observations() {
+    return this.observationBuffer.slice();
+  }
+  clearObservations() {
+    this.observationBuffer.length = 0;
+  }
+  /** Lend the authenticated preview's protocol surface to a Host dispatcher. */
+  /**
+   * Lends the authenticated preview's protocol surface: an owned MessagePort
+   * whose far end the sandbox gave the surface its embedding registered, and
+   * `closed`, settled with a reason when the bridge takes the lending back
+   * (the sandbox document unloaded or was replaced, the surface closed, a
+   * newer lending replaced it, or the bridge was disposed). Messages are
+   * `{type:"data", data}` and `{type:"close", code, reason}`.
+   */
+  async connectProtocol(id = globalThis.crypto.randomUUID(), timeoutMs = SANDBOX_HANDSHAKE_TIMEOUT_MS) {
+    this.assertActive();
+    if (!/^[a-zA-Z0-9_-]{1,128}$/u.test(id)) throw new Error("Invalid preview target identifier.");
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Invalid protocol attachment timeout.");
+    await this.waitForReady(timeoutMs);
+    this.assertActive();
+    if (this.cancelProtocolAttachment) throw new Error("A preview protocol attachment is already in flight.");
+    this.protocolChannel?.finish("Preview protocol replaced");
+    const target = this.options.preview.contentWindow;
+    if (!target) throw new Error("The preview frame is no longer available.");
+    const channel = new MessageChannel();
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        globalThis.clearTimeout(timer);
+        channel.port1.removeEventListener("message", acknowledged);
+        channel.port1.removeEventListener("messageerror", failed);
+        if (this.cancelProtocolAttachment === cancel) this.cancelProtocolAttachment = void 0;
+      };
+      const cancel = (error) => {
+        cleanup();
+        channel.port1.postMessage({ type: "close", code: 1001, reason: error.message });
+        channel.port1.close();
+        channel.port2.close();
+        reject(error);
+      };
+      const failed = () => cancel(new Error("Preview protocol acknowledgement could not be decoded."));
+      const acknowledged = (event) => {
+        if (event.data?.type !== "protocol-ready" || event.data?.id !== id) {
+          cancel(new Error(event.data?.type === "close" ? String(event.data.reason) : "Invalid preview protocol acknowledgement."));
+          return;
+        }
+        cleanup();
+        let settle;
+        const closed = new Promise((resolveClosed) => {
+          settle = resolveClosed;
+        });
+        let done = false;
+        const closedByPreview = (message) => {
+          if (message.data?.type === "close") entry.finish(String(message.data.reason ?? "Preview protocol closed"), true);
+        };
+        const entry = {
+          finish: (reason, fromPreview = false) => {
+            if (done) return;
+            done = true;
+            channel.port1.removeEventListener("message", closedByPreview);
+            if (!fromPreview) {
+              try {
+                channel.port1.postMessage({ type: "close", code: 1001, reason });
+              } catch {
+              }
+            }
+            if (this.protocolChannel === entry) this.protocolChannel = void 0;
+            settle(reason);
+          }
+        };
+        channel.port1.addEventListener("message", closedByPreview);
+        this.protocolChannel = entry;
+        resolve({ port: channel.port1, closed });
+      };
+      const timer = globalThis.setTimeout(() => cancel(new Error("Preview protocol attachment timed out.")), timeoutMs);
+      this.cancelProtocolAttachment = cancel;
+      channel.port1.addEventListener("message", acknowledged);
+      channel.port1.addEventListener("messageerror", failed);
+      channel.port1.start();
+      try {
+        target.postMessage(
+          { channel: SANDBOX_CHANNEL, nonce: this.options.nonce, type: "protocol-connect", payload: { id } },
+          this.options.origin,
+          [channel.port2]
+        );
+      } catch (cause) {
+        cancel(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+    });
+  }
+  resetProtocol(reason) {
+    this.cancelProtocolAttachment?.(new Error(reason));
+    this.protocolChannel?.finish(reason);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.resetProtocol("Preview bridge disposed");
+    window.removeEventListener("message", this.onMessage);
+    this.stopObservingPorts();
+    this.stopObservingHostServices();
+    this.webSockets.closeAll();
+    for (const request of this.requestControllers.values()) request.controller.abort(new Error("The preview bridge was disposed."));
+    for (const request of this.hostFlowRequests.values()) {
+      request.closed = true;
+      if (request.reader) request.track(request.reader.cancel(), true);
+      request.controller.abort(new Error("The preview bridge was disposed."));
+      request.wake?.();
+    }
+    this.requestControllers.clear();
+    this.activeRequestIds.clear();
+    if (this.readyTimer !== void 0) globalThis.clearTimeout(this.readyTimer);
+    if (this.initialPreviewTimer !== void 0) globalThis.clearTimeout(this.initialPreviewTimer);
+    const error = new Error("Browser sandbox bridge was disposed.");
+    if (!this.readyFinished) {
+      this.readyFinished = true;
+      this.rejectReady(error);
+    }
+    if (!this.initialPreviewFinished) {
+      this.initialPreviewFinished = true;
+      this.rejectInitialPreview(error);
+    }
+    for (const waiter of this.readinessWaiters) waiter.reject(error);
+    for (const pending of this.activeCommands.values()) {
+      globalThis.clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.activeCommands.clear();
+  }
+  onMessage = (event) => {
+    if (this.disposed || event.source !== this.options.preview.contentWindow || event.origin !== this.options.origin || !isSandboxEnvelope(event.data, this.options.nonce)) return;
+    const envelope = event.data;
+    if (envelope.type === "request") {
+      const flowControl = envelope.payload?.type;
+      if (flowControl === "stream-pull" || flowControl === "stream-cancel") {
+        this.handleHostFlowControl(envelope.payload);
+        return;
+      }
+      const websocket = websocketRequestType(envelope.payload);
+      const initialNavigation = !websocket && isInitialPreviewNavigation(envelope.payload);
+      const operation = websocket ? this.handleWebSocket(envelope.payload) : this.handleRequest(envelope.payload);
+      void operation.then(() => {
+        if (initialNavigation) this.finishInitialPreview();
+      }).catch((error) => {
+        const requestId = envelope.payload?.id;
+        this.send({
+          type: websocket ? "websocket-error" : "response",
+          id: requestId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    } else if (envelope.type === "protocol-disconnect") {
+      this.resetProtocol("Preview document unloaded");
+      this.bridgeConnected = false;
+      this.previewConnected = false;
+    } else if (envelope.type === "ready") {
+      const documentId = envelope.payload?.documentId;
+      if (typeof documentId === "string" && documentId !== this.protocolDocumentId) {
+        if (this.protocolDocumentId !== void 0) this.resetProtocol("Preview document replaced");
+        this.protocolDocumentId = documentId;
+      }
+      this.bridgeConnected = true;
+      for (const service of this.options.hostFetchServices?.snapshot() ?? []) {
+        this.send({ type: "server-registered", data: { port: service.port, hostname: "127.0.0.1", ...service.capability } });
+      }
+      if (!this.readyFinished) {
+        this.readyFinished = true;
+        if (this.readyTimer !== void 0) globalThis.clearTimeout(this.readyTimer);
+        this.resolveReady();
+      }
+      this.announceReady();
+    } else if (envelope.type === "preview-load") {
+      this.finishInitialPreview();
+    } else if (envelope.type === "rendered") {
+      const revision = envelope.payload?.revision;
+      if (typeof revision === "string" && revision.length > 0 && revision.length <= 128) this.options.onRendered?.(revision);
+    } else if (envelope.type === "command-result") {
+      this.finishCommand(envelope.payload);
+    } else if (envelope.type === "observation") {
+      const observation = validatePreviewObservation(envelope.payload);
+      if (!observation) return;
+      this.observationBuffer.push(observation);
+      if (this.observationBuffer.length > this.limits.maxPreviewObservations) this.observationBuffer.shift();
+      this.options.onObservation?.(observation);
+    } else if (envelope.type === "error") {
+      const message = envelope.payload?.message || "Sandbox bridge failed.";
+      const error = new Error(message);
+      for (const waiter of this.readinessWaiters) waiter.reject(error);
+      if (!this.readyFinished) {
+        this.readyFinished = true;
+        if (this.readyTimer !== void 0) globalThis.clearTimeout(this.readyTimer);
+        this.rejectReady(error);
+      }
+      if (!this.initialPreviewFinished) {
+        this.initialPreviewFinished = true;
+        if (this.initialPreviewTimer !== void 0) globalThis.clearTimeout(this.initialPreviewTimer);
+        this.rejectInitialPreview(error);
+      }
+      for (const pending of this.activeCommands.values()) {
+        globalThis.clearTimeout(pending.timeout);
+        pending.reject(error);
+      }
+      this.activeCommands.clear();
+      this.options.onError?.(error);
+    }
+  };
+  async command(input, timeoutMs = SANDBOX_COMMAND_TIMEOUT_MS) {
+    this.assertActive();
+    await this.waitForReady();
+    this.assertActive();
+    if (this.activeCommands.size >= this.limits.maxPreviewCommands) {
+      throw new Error("Preview command concurrency exceeded.");
+    }
+    const id = this.nextCommandId++;
+    const command = { ...input, id };
+    return new Promise((resolve, reject) => {
+      const timeout = globalThis.setTimeout(() => {
+        this.activeCommands.delete(id);
+        reject(new Error(`Preview command ${input.operation} timed out.`));
+      }, timeoutMs);
+      this.activeCommands.set(id, {
+        resolve: (value) => resolve(value),
+        reject,
+        timeout
+      });
+      try {
+        const target = this.options.preview.contentWindow;
+        if (!target) throw new Error("The preview frame is no longer available.");
+        target.postMessage({
+          channel: SANDBOX_CHANNEL,
+          nonce: this.options.nonce,
+          type: "command",
+          payload: command
+        }, this.options.origin);
+      } catch (cause) {
+        globalThis.clearTimeout(timeout);
+        this.activeCommands.delete(id);
+        reject(cause);
+      }
+    });
+  }
+  finishCommand(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
+    const result = payload;
+    if (!Number.isSafeInteger(result.id)) return;
+    const pending = this.activeCommands.get(result.id);
+    if (!pending) return;
+    this.activeCommands.delete(result.id);
+    globalThis.clearTimeout(pending.timeout);
+    if (typeof result.error === "string") pending.reject(new Error(result.error));
+    else pending.resolve(result.result);
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("Browser sandbox bridge is disposed.");
+  }
+  get limits() {
+    return this.options.policy?.limits ?? DEFAULT_BROWSER_RUNTIME_LIMITS;
+  }
+  armStartupTimeouts() {
+    if (!this.readyFinished && this.readyTimer === void 0) {
+      this.readyTimer = globalThis.setTimeout(() => {
+        this.readyTimer = void 0;
+        this.readyFinished = true;
+        this.rejectReady(new Error("Sandbox bridge handshake timed out."));
+      }, SANDBOX_HANDSHAKE_TIMEOUT_MS);
+    }
+    if (!this.initialPreviewFinished && this.initialPreviewTimer === void 0) {
+      this.initialPreviewTimer = globalThis.setTimeout(() => {
+        this.initialPreviewTimer = void 0;
+        this.initialPreviewFinished = true;
+        this.rejectInitialPreview(new Error("Generated preview startup timed out."));
+      }, SANDBOX_HANDSHAKE_TIMEOUT_MS);
+    }
+  }
+  finishInitialPreview() {
+    if (this.disposed || this.previewConnected) return;
+    this.previewConnected = true;
+    if (this.initialPreviewTimer !== void 0) globalThis.clearTimeout(this.initialPreviewTimer);
+    if (!this.initialPreviewFinished) {
+      this.initialPreviewFinished = true;
+      this.resolveInitialPreview();
+    }
+    this.options.onPreviewLoad?.();
+    this.announceReady();
+  }
+  announceReady() {
+    if (!this.bridgeConnected || !this.previewConnected) return;
+    for (const waiter of this.readinessWaiters) waiter.resolve();
+    if (!this.announcedReady) {
+      this.announcedReady = true;
+      this.options.onReady?.();
+    }
+  }
+  send(message) {
+    if (this.disposed) return;
+    this.options.preview.contentWindow?.postMessage({
+      channel: SANDBOX_CHANNEL,
+      nonce: this.options.nonce,
+      type: "response",
+      payload: message
+    }, this.options.origin);
+  }
+  handleHostFlowControl(message) {
+    if (!message || typeof message !== "object") return;
+    const control = message;
+    if (!Number.isSafeInteger(control.id)) return;
+    const request = this.hostFlowRequests.get(control.id);
+    if (!request || request.closed) return;
+    if (control.type === "stream-cancel") {
+      request.closed = true;
+      if (request.reader) request.track(request.reader.cancel(), true);
+      request.controller.abort(new Error("The guest cancelled the Host Fetch response."));
+      request.wake?.();
+    } else if (control.type === "stream-pull") {
+      if (request.credit) return;
+      request.credit = true;
+      request.wake?.();
+    }
+  }
+  async handleHostFlowRequest(request, controller) {
+    const service = this.options.hostFetchServices?.get(request.data.port);
+    if (!service || !request.data.flowControl || !request.data.streaming) {
+      throw new Error("Host Fetch service requires flow-control protocol 1.");
+    }
+    if ((request.data.body?.byteLength ?? 0) > service.maxRequestBytes) {
+      throw new Error(`Host Fetch-service upload exceeds ${service.maxRequestBytes} bytes.`);
+    }
+    const state = {
+      port: service.port,
+      controller,
+      credit: false,
+      closed: false,
+      track: (operation, critical) => service.track(operation, critical)
+    };
+    this.hostFlowRequests.set(request.id, state);
+    let cleanupFailure;
+    const abortOwner = () => controller.abort(service.signal.reason);
+    service.signal.addEventListener("abort", abortOwner, { once: true });
+    try {
+      if (service.signal.aborted) abortOwner();
+      if (service.ready) await waitForBrowserOperation(service.ready, controller.signal);
+      const method = request.data.method;
+      const url = `http://127.0.0.1:${service.port}${request.data.url}`;
+      const running = Promise.resolve().then(() => service.fetch(new Request(url, {
+        method,
+        headers: request.data.headers,
+        ...method === "GET" || method === "HEAD" || !request.data.body ? {} : { body: request.data.body },
+        signal: controller.signal
+      })));
+      service.track(running);
+      service.track(running.then(async (late) => {
+        if (controller.signal.aborted && late instanceof Response) await late.body?.cancel();
+      }, () => void 0), true);
+      const response = await waitForBrowserOperation(running, controller.signal);
+      if (!(response instanceof Response)) throw new Error("Host Fetch handler did not return a Response.");
+      if (controller.signal.aborted) {
+        try {
+          await response.body?.cancel(controller.signal.reason);
+        } catch (cause) {
+          cleanupFailure = cause;
+          throw cause;
+        }
+        return;
+      }
+      this.send({ type: "stream-start", id: request.id, data: {
+        statusCode: response.status,
+        statusMessage: response.statusText,
+        headers: Object.fromEntries(response.headers)
+      } });
+      if (method === "HEAD" || response.status === 204 || response.status === 205 || response.status === 304 || !response.body) {
+        try {
+          await response.body?.cancel();
+        } catch (cause) {
+          cleanupFailure = cause;
+          throw cause;
+        }
+        this.send({ type: "stream-end", id: request.id });
+        return;
+      }
+      const reader = response.body.getReader();
+      state.reader = reader;
+      let responseBytes = 0;
+      let complete = false;
+      const takeCredit = async () => {
+        if (!state.credit) {
+          await waitForBrowserOperation(new Promise((resolve) => {
+            state.wake = resolve;
+          }), controller.signal);
+          delete state.wake;
+        }
+        if (state.closed || controller.signal.aborted) return false;
+        state.credit = false;
+        return true;
+      };
+      try {
+        while (!state.closed && !controller.signal.aborted) {
+          if (!await takeCredit()) break;
+          const reading = reader.read();
+          service.track(reading);
+          const next = await waitForBrowserOperation(reading, controller.signal);
+          if (next.done) {
+            complete = true;
+            this.send({ type: "stream-end", id: request.id });
+            return;
+          }
+          if (!(next.value instanceof Uint8Array)) throw new Error("Host Fetch-service producer did not yield bytes.");
+          responseBytes += next.value.byteLength;
+          if (responseBytes > this.limits.maxVirtualResponseBytes) throw new Error("Host Fetch-service response exceeds its byte limit.");
+          for (let offset = 0; offset < next.value.byteLength || offset === 0 && next.value.byteLength === 0; offset += HOST_FETCH_MAX_CHUNK_BYTES) {
+            if (offset > 0 && !await takeCredit()) break;
+            if (state.closed || controller.signal.aborted) break;
+            this.send({ type: "stream-chunk", id: request.id, data: {
+              chunkBase64: encodeBase64(next.value.subarray(offset, offset + HOST_FETCH_MAX_CHUNK_BYTES))
+            } });
+            if (next.value.byteLength === 0) break;
+          }
+        }
+      } finally {
+        if (!complete) {
+          try {
+            await reader.cancel();
+          } catch (cause) {
+            cleanupFailure = cause;
+          }
+        }
+        try {
+          reader.releaseLock();
+        } catch (cause) {
+          if (cleanupFailure === void 0) cleanupFailure = cause;
+        }
+        if (cleanupFailure !== void 0) throw cleanupFailure;
+      }
+    } catch (cause) {
+      if (!state.closed && !controller.signal.aborted) {
+        this.send({ type: "stream-error", id: request.id, error: cause instanceof Error ? cause.message : String(cause) });
+      }
+      if (cleanupFailure !== void 0) throw cause;
+    } finally {
+      state.closed = true;
+      service.signal.removeEventListener("abort", abortOwner);
+      this.hostFlowRequests.delete(request.id);
+    }
+  }
+  async handleRequest(message) {
+    this.assertActive();
+    const request = validateSandboxRequest(
+      message,
+      (port) => this.options.bridge.getServerPorts().includes(port),
+      this.limits
+    );
+    if (this.requestControllers.has(request.id)) throw new Error("Duplicate virtual-server request identifier.");
+    const admittedService = this.options.hostFetchServices?.get(request.data.port);
+    const controller = new AbortController();
+    this.requestControllers.set(request.id, { port: request.data.port, controller });
+    const signal = controller.signal;
+    const abortOwner = () => controller.abort(admittedService?.signal.reason);
+    admittedService?.signal.addEventListener("abort", abortOwner, { once: true });
+    if (admittedService?.signal.aborted) abortOwner();
+    let acquired = false;
+    let active = true;
+    try {
+      while (this.activeRequestIds.size >= this.limits.maxVirtualRequests) {
+        await new Promise((resolve, reject) => {
+          const enter = () => {
+            signal.removeEventListener("abort", cancel);
+            resolve();
+          };
+          const cancel = () => {
+            const index = this.waitingRequests.indexOf(enter);
+            if (index >= 0) this.waitingRequests.splice(index, 1);
+            signal.removeEventListener("abort", cancel);
+            reject(signal.reason);
+          };
+          if (signal.aborted) {
+            reject(signal.reason);
+            return;
+          }
+          this.waitingRequests.push(enter);
+          signal.addEventListener("abort", cancel, { once: true });
+        });
+      }
+      signal.throwIfAborted();
+      if (this.options.hostFetchServices?.get(request.data.port) !== admittedService) {
+        throw new Error("Virtual-server registration changed while the request waited.");
+      }
+      this.activeRequestIds.add(request.id);
+      acquired = true;
+      const { method, url, headers, body, streaming } = request.data;
+      if (admittedService) {
+        const operation = this.handleHostFlowRequest(request, controller);
+        admittedService.track(operation, true);
+        await operation;
+        return;
+      }
+      if (request.data.flowControl) throw new Error("Flow-control protocol is not registered for this port.");
+      if (streaming && this.options.bridge.handleStreamingRequest) {
+        let responseBytes = 0;
+        let started = false;
+        let ended = false;
+        let resolveEnd;
+        let rejectEnd;
+        const complete = new Promise((resolve, reject) => {
+          resolveEnd = resolve;
+          rejectEnd = reject;
+        });
+        void complete.catch(() => void 0);
+        const stop = new AbortController();
+        const stopProducer = () => {
+          if (!stop.signal.aborted) stop.abort(signal.reason);
+        };
+        signal.addEventListener("abort", stopProducer, { once: true });
+        const fail = (cause) => {
+          active = false;
+          rejectEnd(cause);
+          stopProducer();
+        };
+        const handler = this.options.bridge.handleStreamingRequest(
+          request.data.port,
+          method,
+          url,
+          headers,
+          body,
+          {
+            start: (statusCode, statusMessage, responseHeaders) => {
+              if (!active || signal.aborted) return;
+              if (started) {
+                fail(new Error("The preview response already started."));
+                return;
+              }
+              started = true;
+              try {
+                this.send({ type: "stream-start", id: request.id, data: { statusCode, statusMessage, headers: responseHeaders } });
+              } catch (cause) {
+                fail(cause);
+              }
+            },
+            chunk: (chunk) => {
+              if (!active || signal.aborted) return;
+              if (!started || ended) {
+                fail(new Error("The preview response is not accepting chunks."));
+                return;
+              }
+              responseBytes += chunk.byteLength;
+              if (responseBytes > this.limits.maxVirtualResponseBytes) {
+                fail(new Error(`Virtual-server streaming response exceeds ${this.limits.maxVirtualResponseBytes} bytes.`));
+                return;
+              }
+              try {
+                this.send({ type: "stream-chunk", id: request.id, data: { chunkBase64: encodeBase64(chunk) } });
+              } catch (cause) {
+                fail(cause);
+              }
+            },
+            end: () => {
+              if (!active || signal.aborted || ended) return;
+              if (!started) {
+                fail(new Error("The preview response ended before its headers."));
+                return;
+              }
+              ended = true;
+              try {
+                this.send({ type: "stream-end", id: request.id });
+                resolveEnd();
+              } catch (cause) {
+                fail(cause);
+              }
+            }
+          },
+          { signal: stop.signal }
+        );
+        const handled = await waitForBrowserOperation(Promise.race([handler, complete.then(() => true)]), signal);
+        if (handled) {
+          await waitForBrowserOperation(complete, signal);
+          return;
+        }
+        if (started || ended || responseBytes > 0) throw new Error("The preview streaming handler wrote a response before declining the request.");
+      }
+      const response = await waitForBrowserOperation(() => this.options.bridge.handleRequest(request.data.port, method, url, headers, body), signal);
+      const rawBody = response.body instanceof Uint8Array ? response.body : new Uint8Array();
+      if (rawBody.byteLength > this.limits.maxVirtualResponseBytes) {
+        throw new Error(`Virtual-server response body exceeds ${this.limits.maxVirtualResponseBytes} bytes.`);
+      }
+      const responseBody = rewriteHtmlModules(rawBody, response.headers, this.options.htmlModuleRewrites);
+      if (responseBody.byteLength > this.limits.maxVirtualResponseBytes) throw new Error("The rewritten preview response exceeds its byte limit.");
+      if (streaming) {
+        this.send({
+          type: "stream-start",
+          id: request.id,
+          data: { statusCode: response.statusCode, statusMessage: response.statusMessage, headers: response.headers }
+        });
+        if (responseBody.length > 0) {
+          this.send({ type: "stream-chunk", id: request.id, data: { chunkBase64: encodeBase64(responseBody) } });
+        }
+        this.send({ type: "stream-end", id: request.id });
+        return;
+      }
+      this.send({
+        type: "response",
+        id: request.id,
+        data: {
+          statusCode: response.statusCode,
+          statusMessage: response.statusMessage,
+          headers: response.headers,
+          bodyBase64: encodeBase64(responseBody)
+        }
+      });
+    } finally {
+      active = false;
+      admittedService?.signal.removeEventListener("abort", abortOwner);
+      this.requestControllers.delete(request.id);
+      if (acquired) {
+        this.activeRequestIds.delete(request.id);
+        this.waitingRequests.shift()?.();
+      }
+    }
+  }
+  async handleWebSocket(message) {
+    await this.socketRelay.handle(message);
+  }
+};
+function isInitialPreviewNavigation(message) {
+  if (!message || typeof message !== "object") return false;
+  const request = message;
+  return request.type === "request" && request.data?.method === "GET" && request.data.url === "/" && request.data.headers?.["sec-fetch-dest"] === "iframe";
+}
+function validatePreviewObservation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const candidate = value;
+  if (!Number.isFinite(candidate.timestamp) || typeof candidate.kind !== "string") return;
+  if (candidate.kind === "console") {
+    if (!(/* @__PURE__ */ new Set(["debug", "info", "log", "warn", "error"])).has(String(candidate.level)) || typeof candidate.message !== "string" || candidate.message.length > 32768) return;
+    return candidate;
+  }
+  if (candidate.kind === "exception" || candidate.kind === "unhandledrejection") {
+    if (typeof candidate.message !== "string" || candidate.message.length > 32768 || candidate.stack !== void 0 && (typeof candidate.stack !== "string" || candidate.stack.length > 65536) || candidate.source !== void 0 && (typeof candidate.source !== "string" || candidate.source.length > 16384)) {
+      return;
+    }
+    return candidate;
+  }
+  if (candidate.kind === "navigation") {
+    if (typeof candidate.url !== "string" || candidate.url.length > 16384 || typeof candidate.title !== "string" || candidate.title.length > 4096) return;
+    return candidate;
+  }
+}
+
+// packages/cdp/dist/preview-browser-host.js
+var CLEAR_TIMEOUT_MS = 15e3;
+var ORIGINS_RECORD = "browser-substrate.context-origins";
+var ORIGIN_LOCK = "browser-substrate.context-origin:";
+var SPARE_ORIGINS = 4;
+function createPreviewBrowserHost(options) {
+  const sandboxPath = options.sandboxPath ?? "/sandbox.html";
+  const contexts = /* @__PURE__ */ new Map();
+  const emptied = [];
+  const held = /* @__PURE__ */ new Map();
+  const recorded = () => {
+    try {
+      const value = JSON.parse(localStorage.getItem(ORIGINS_RECORD) ?? "[]");
+      return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+    } catch {
+      return [];
+    }
+  };
+  const record = (origins) => {
+    try {
+      localStorage.setItem(ORIGINS_RECORD, JSON.stringify([...new Set(origins)]));
+    } catch {
+    }
+  };
+  const hold = (origin, ifFree) => new Promise((acquired) => {
+    if (!("locks" in navigator)) {
+      acquired(!ifFree);
+      return;
+    }
+    void navigator.locks.request(`${ORIGIN_LOCK}${origin}`, { ifAvailable: ifFree }, (lock) => {
+      if (!lock) {
+        acquired(false);
+        return void 0;
+      }
+      acquired(true);
+      return new Promise((release2) => held.set(origin, release2));
+    });
+  });
+  const retire = (origin) => clearOrigin(origin).then(() => {
+    record(recorded().filter((item) => item !== origin));
+  }, () => void 0).finally(() => {
+    held.get(origin)?.();
+    held.delete(origin);
+  });
+  const release = (origin) => {
+    if (emptied.length >= SPARE_ORIGINS) {
+      void retire(origin);
+      return;
+    }
+    emptied.push({ origin, ready: clearOrigin(origin, "reuse").then(() => true, () => false) });
+  };
+  let adopting = Promise.resolve();
+  for (const origin of recorded()) {
+    adopting = adopting.then(async () => {
+      if (await hold(origin, true))
+        release(origin);
+    });
+  }
+  const pages = /* @__PURE__ */ new Map();
+  const contextOrigin = () => {
+    const label = `c-${[...crypto.getRandomValues(new Uint8Array(8))].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+    if (options.contextOrigin)
+      return new URL(options.contextOrigin(label)).origin;
+    const base = new URL(options.sandboxOrigin);
+    if (/^[0-9.]+$/u.test(base.hostname) || base.hostname.startsWith("[")) {
+      throw new Error(`Isolated browser contexts need a sandbox host name; ${base.hostname} is an address.`);
+    }
+    if (base.hostname.endsWith(".workers.dev")) {
+      throw new Error(`Isolated browser contexts need the sandbox on a zone of its own; ${base.hostname} is a workers.dev host.`);
+    }
+    return `${base.protocol}//${label}.${base.host}`;
+  };
+  const frameFor = (origin, query) => {
+    const frame2 = document.createElement("iframe");
+    frame2.style.cssText = "border:0;width:1280px;height:720px;display:block";
+    const url = new URL(sandboxPath, origin);
+    for (const [key, value] of Object.entries(query))
+      url.searchParams.set(key, value);
+    frame2.src = url.href;
+    options.mount.append(frame2);
+    return frame2;
+  };
+  const closePage = async (id) => {
+    const page = pages.get(id);
+    if (!page)
+      return;
+    pages.delete(id);
+    page.bridge.dispose();
+    page.frame.remove();
+  };
+  const clearOrigin = async (origin, clear = "1") => {
+    const nonce = crypto.randomUUID();
+    const frame2 = frameFor(origin, { parentOrigin: location.origin, nonce, clear });
+    try {
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          cleanup();
+          reject(new Error(`Clearing ${origin} timed out.`));
+        }, CLEAR_TIMEOUT_MS);
+        const receive = (event) => {
+          if (event.origin !== origin || event.source !== frame2.contentWindow)
+            return;
+          const data = event.data;
+          if (data?.channel !== SANDBOX_CHANNEL || data.nonce !== nonce)
+            return;
+          if (data.type === "cleared") {
+            cleanup();
+            resolve();
+          } else if (data.type === "error") {
+            cleanup();
+            reject(new Error(data.payload?.message ?? `Clearing ${origin} failed.`));
+          }
+        };
+        const cleanup = () => {
+          clearTimeout(timer);
+          window.removeEventListener("message", receive);
+        };
+        window.addEventListener("message", receive);
+      });
+    } finally {
+      frame2.remove();
+    }
+  };
+  const contextHost = {
+    async createContext(context, signal) {
+      if (context.proxyServer !== void 0 || context.proxyBypassList !== void 0) {
+        throw new Error("A context's network is the tab's; a per-context proxy is unavailable.");
+      }
+      if (context.originsWithUniversalNetworkAccess?.length) {
+        throw new Error("Universal network access for named origins is unavailable in the tab.");
+      }
+      signal.throwIfAborted();
+      let origin;
+      while (!origin && emptied.length > 0) {
+        const candidate = emptied.shift();
+        if (await candidate.ready)
+          origin = candidate.origin;
+        else {
+          held.get(candidate.origin)?.();
+          held.delete(candidate.origin);
+        }
+        signal.throwIfAborted();
+      }
+      if (!origin) {
+        origin = contextOrigin();
+        await hold(origin, false);
+        record([...recorded(), origin]);
+      }
+      contexts.set(context.id, { origin });
+    },
+    async disposeContext(id) {
+      const context = contexts.get(id);
+      if (!context)
+        return;
+      await Promise.all([...pages].filter(([, page]) => page.contextId === id).map(([pageId]) => closePage(pageId)));
+      contexts.delete(id);
+      release(context.origin);
+    }
+  };
+  const pageHost = {
+    async createPage(page, signal) {
+      const context = page.browserContextId === void 0 ? void 0 : contexts.get(page.browserContextId);
+      if (page.browserContextId !== void 0 && !context)
+        throw new Error("No browser context with given id");
+      const origin = context?.origin ?? new URL(options.sandboxOrigin).origin;
+      const nonce = crypto.randomUUID();
+      const opening = guestAddress(page.url);
+      const port = 0;
+      const frame2 = frameFor(origin, { parentOrigin: location.origin, nonce, port: String(port) });
+      const bridge = new BrowserSandboxBridge({ ...options.bridge, preview: frame2, origin, nonce, port });
+      pages.set(page.id, { frame: frame2, bridge, ...page.browserContextId !== void 0 ? { contextId: page.browserContextId } : {} });
+      const abort = () => {
+        void closePage(page.id);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      try {
+        const channel = await bridge.connectProtocol(page.id);
+        const transport = new MessagePortTransport(channel.port);
+        void channel.closed.then((reason) => transport.close(1001, reason));
+        await bridge.initialPreviewReady;
+        signal.throwIfAborted();
+        await options.attachSurface(transport, page.id, signal);
+        if (opening)
+          await bridge.navigate(`${origin}/__virtual__/${opening.port}${opening.path}`);
+      } catch (cause) {
+        await closePage(page.id);
+        throw cause;
+      } finally {
+        signal.removeEventListener("abort", abort);
+      }
+    },
+    closePage
+  };
+  return {
+    contextHost,
+    pageHost,
+    async dispose() {
+      await Promise.allSettled([...pages.keys()].map(closePage));
+      const origins = [...contexts.values()].map((context) => context.origin);
+      contexts.clear();
+      await adopting;
+      for (const entry of emptied.splice(0))
+        if (await entry.ready)
+          origins.push(entry.origin);
+      await Promise.allSettled(origins.map(retire));
+    }
+  };
+}
+function guestAddress(url) {
+  if (url === "" || url === "about:blank")
+    return void 0;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid page URL: ${url}`);
+  }
+  const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !loopback) {
+    throw new Error(`A page opens on a guest server of the tab; ${url} is not one.`);
+  }
+  const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
+  return { port, path: `${parsed.pathname}${parsed.search}${parsed.hash}` };
+}
+
+// packages/cdp/dist/preview-cdp-endpoint.js
+var REATTACH_DELAY_MS = 250;
+function publishPreviewCdp(options) {
+  const { bridge, port } = options;
+  let endpoint;
+  const host = options.browser ? createPreviewBrowserHost({
+    ...options.browser,
+    attachSurface: (peer, id, signal) => attachAndAwait(endpoint, peer, id, signal)
+  }) : void 0;
+  endpoint = createSocketEndpoint({
+    address: `127.0.0.1:${port}`,
+    ...host ? { contextHost: host.contextHost, pageHost: host.pageHost } : {},
+    ...options.downloads ? { downloadHost: { write: (_context, path, bytes) => options.downloads.write(path, bytes) } } : {},
+    ...options.files ? { fileHost: options.files } : {}
+  });
+  const unlisten = options.listen(port, (socket) => endpoint.serve(socket));
+  const unpublish = options.portTable ? servePortTable(endpoint, options.portTable) : options.discoveryTable ? serveDiscovery(endpoint, options.discoveryTable) : void 0;
+  const targetId = options.targetId ?? "preview";
+  let closed = false;
+  if (bridge)
+    void (async () => {
+      while (!closed) {
+        try {
+          const channel = await bridge.connectProtocol(targetId);
+          const transport = new MessagePortTransport(channel.port);
+          void channel.closed.then((reason) => transport.close(1001, reason));
+          if (closed) {
+            transport.close(1001, "Preview CDP publication closed");
+            return;
+          }
+          const lost = new Promise((resolve) => transport.on("close", resolve));
+          endpoint.attachSurface(transport);
+          await lost;
+        } catch (error) {
+          if (error instanceof Error && error.message === "Browser sandbox bridge is disposed.")
+            return;
+        }
+        if (!closed)
+          await new Promise((resolve) => setTimeout(resolve, REATTACH_DELAY_MS));
+      }
+    })();
+  return {
+    port,
+    url: `http://127.0.0.1:${port}`,
+    attachClient: (peer) => endpoint.attachClient(peer),
+    async close() {
+      if (closed)
+        return;
+      closed = true;
+      unlisten();
+      unpublish?.();
+      await endpoint.close();
+      await host?.dispose();
+    }
+  };
+}
+async function attachAndAwait(endpoint, peer, id, signal) {
+  let lost = false;
+  peer.on("close", () => {
+    lost = true;
+  });
+  endpoint.attachSurface(peer);
+  while (!endpoint.targets().some((target) => target.id === id)) {
+    signal.throwIfAborted();
+    if (lost)
+      throw new Error("The page surface closed before it registered.");
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+function serveDiscovery(endpoint, table) {
+  const encoder5 = new TextEncoder();
+  table.ports.registerServer({
+    listening: true,
+    address: () => ({ port: table.port, address: "0.0.0.0", family: "IPv4" }),
+    async handleRequest(method, url, headers) {
+      if (method !== "GET" && method !== "HEAD")
+        return { statusCode: 405, headers: { allow: "GET, HEAD" } };
+      const host = headers.host ?? headers.Host ?? `127.0.0.1:${table.port}`;
+      const loopback = /^(localhost|127\.0\.0\.1|\[::1\])(:|$)/u.test(host);
+      const { status, body } = endpoint.discovery(new URL(url, "http://localhost").pathname, loopback ? host : `wss://${host}`);
+      return { statusCode: status, headers: { "content-type": "application/json; charset=UTF-8" }, ...method === "GET" ? { body: encoder5.encode(JSON.stringify(body)) } : {} };
+    }
+  }, table.port);
+  return () => table.ports.unregisterServer(table.port);
+}
+function servePortTable(endpoint, table) {
+  const unregisterDiscovery = serveDiscovery(endpoint, table);
+  const unregisterSockets = table.webSockets.register(table.port, {
+    open(path, _protocols, handlers) {
+      const messageListeners = [];
+      const closeListeners = [];
+      let state = 1;
+      const finish = () => {
+        if (state === 3)
+          return;
+        state = 3;
+        for (const listener of closeListeners)
+          listener();
+      };
+      const peer = {
+        get readyState() {
+          return state;
+        },
+        send: (data) => {
+          if (state === 1)
+            handlers.message({ kind: "text", text: data });
+        },
+        close: (code, reason) => {
+          if (state !== 1)
+            return;
+          handlers.close(code, reason, true);
+          finish();
+        },
+        on: ((event, listener) => {
+          if (event === "message")
+            messageListeners.push(listener);
+          else
+            closeListeners.push(listener);
+        })
+      };
+      queueMicrotask(() => {
+        handlers.open("");
+        endpoint.connect(peer, path);
+      });
+      return {
+        send(data) {
+          if (data.kind !== "text") {
+            peer.close(1003, "CDP messages are text");
+            return;
+          }
+          for (const listener of messageListeners)
+            listener(data.text);
+        },
+        close(code = 1e3, reason = "") {
+          handlers.close(code, reason, true);
+          finish();
+        }
+      };
+    }
+  });
+  return () => {
+    unregisterSockets();
+    unregisterDiscovery();
+  };
+}
+
+// packages/cdp/dist/tab-chromium.js
+var TAB_CDP_PORT = 9222;
+function installTabChromium(options) {
+  const { runtime } = options;
+  const fs = runtime.filesystem;
+  const publication = publishPreviewCdp({
+    ...options.bridge ? { bridge: options.bridge } : {},
+    port: options.port ?? TAB_CDP_PORT,
+    listen: options.listen,
+    browser: options.browser,
+    ...options.portTable ? { portTable: options.portTable } : {},
+    ...options.discoveryTable ? { discoveryTable: options.discoveryTable } : {},
+    downloads: {
+      async write(path, bytes) {
+        fs.mkdirSync(path.slice(0, path.lastIndexOf("/")) || "/", { recursive: true });
+        fs.writeFileSync(path, bytes);
+      }
+    },
+    files: {
+      async read(path) {
+        const stat = fs.statSync(path);
+        if (!stat.isFile())
+          throw new Error(`Not a file: ${path}`);
+        const name = path.slice(path.lastIndexOf("/") + 1);
+        return { data: await fs.readFile(path), name, type: mimeTypeOf(name), lastModified: Math.round(stat.mtimeMs) };
+      },
+      async list(path) {
+        if (!fs.statSync(path).isDirectory())
+          return void 0;
+        const files = [];
+        const walk = (directory, prefix) => {
+          for (const name of fs.readdirSync(directory).map(String).sort()) {
+            const entry = `${directory}/${name}`;
+            if (fs.statSync(entry).isDirectory())
+              walk(entry, `${prefix}${name}/`);
+            else
+              files.push(`${prefix}${name}`);
+          }
+        };
+        walk(path.replace(/\/+$/u, ""), "");
+        return files;
+      }
+    }
+  });
+  const face = chromiumFaceRunner((peer) => publication.attachClient(peer));
+  for (const name of runtime.baselines.find((row) => row.provider.name === "chromium")?.commands ?? [])
+    runtime.registerProgram(name, face, { descriptors: true });
+  const stopPlacing = keepFacePlaced(runtime, options.home, options.roots);
+  return {
+    publication,
+    async dispose() {
+      stopPlacing();
+      await publication.close();
+    }
+  };
+}
+function installUnavailableTabChromium(options) {
+  const message = `chromium: ${options.reason}
+`;
+  const refuse = async (_argv, run) => {
+    run.onStderr?.(message);
+    return { stdout: "", stderr: message, exitCode: 1 };
+  };
+  for (const name of options.runtime.baselines.find((row) => row.provider.name === "chromium")?.commands ?? [])
+    options.runtime.registerProgram(name, refuse, { descriptors: true });
+  return keepFacePlaced(options.runtime, options.home, options.roots);
+}
+function keepFacePlaced(runtime, home, roots) {
+  const fs = runtime.filesystem;
+  const baseline = runtime.baselines.find((row) => row.provider.name === "chromium")?.chromium;
+  if (!baseline)
+    return () => void 0;
+  let placed = "";
+  const place = async () => {
+    const revisions = (await playwrightChromiumRevisions(fs, roots)).sort().join(",");
+    if (revisions === placed)
+      return;
+    placed = revisions;
+    await placeChromiumFace(fs, `${home}/.cache/ms-playwright`, revisions ? revisions.split(",") : [], baseline);
+  };
+  const placing = setInterval(() => {
+    void place().catch((cause) => console.error("Chromium face placement failed:", cause));
+  }, 2e3);
+  void place().catch((cause) => console.error("Chromium face placement failed:", cause));
+  return () => clearInterval(placing);
+}
+function mimeTypeOf(name) {
+  const extension = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
+  return {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    bmp: "image/bmp",
+    avif: "image/avif",
+    txt: "text/plain",
+    html: "text/html",
+    htm: "text/html",
+    css: "text/css",
+    js: "text/javascript",
+    mjs: "text/javascript",
+    json: "application/json",
+    xml: "text/xml",
+    csv: "text/csv",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    gz: "application/gzip",
+    wasm: "application/wasm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    woff: "font/woff",
+    woff2: "font/woff2"
+  }[extension] ?? "";
+}
+export {
+  TAB_CDP_PORT,
+  installTabChromium,
+  installUnavailableTabChromium
+};