@tutti-os/browser-node 0.0.1

package/dist/electron-main/index.js

@@ -0,0 +1,1492 @@
+import {
+  isBrowserSessionPartitionAllowed,
+  resolveBrowserSessionPartition
+} from "../chunk-UTXZLRPE.js";
+import {
+  normalizeHostBrowserComparableUrl,
+  resolveBrowserNavigationUrl,
+  resolveHostBrowserNavigationUrl
+} from "../chunk-LVVPDNEF.js";
+
+// src/electron-main/loopbackPreviewProxy.ts
+import {
+  createServer,
+  request as httpRequest
+} from "http";
+import { request as httpsRequest } from "https";
+import { pipeline } from "stream";
+import WebSocket, { WebSocketServer } from "ws";
+var defaultLoopbackPreviewCacheTtlMs = 3e4;
+var loopbackHostPattern = /^(localhost|127(?:\.\d{1,3}){0,3})$/i;
+var loopbackPreviewProxyBypassRules = "*;<-loopback>;https://*;wss://*";
+var hopByHopHeaders = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function createBrowserNodeLoopbackPreviewProxy({
+  logger,
+  resolveSession,
+  routing
+}) {
+  const configuredSessions = /* @__PURE__ */ new WeakSet();
+  const targetCache = /* @__PURE__ */ new Map();
+  const downstreamWebSocketServer = new WebSocketServer({ noServer: true });
+  let server = null;
+  let serverStartPromise = null;
+  const cacheTtlMs = routing.cacheTtlMs ?? defaultLoopbackPreviewCacheTtlMs;
+  const fallback = routing.fallback ?? "direct";
+  const pruneExpiredTargets = (now) => {
+    for (const [cacheKey, cachedTarget] of targetCache.entries()) {
+      if (cachedTarget.expiresAt <= now) {
+        targetCache.delete(cacheKey);
+      }
+    }
+  };
+  const start = async () => {
+    if (server?.listening) {
+      return addressForTesting();
+    }
+    if (serverStartPromise) {
+      return serverStartPromise;
+    }
+    serverStartPromise = new Promise((resolve, reject) => {
+      const nextServer = createServer((request, response) => {
+        void handleRequest(request, response);
+      });
+      nextServer.on("upgrade", (request, socket, head) => {
+        void handleUpgrade(request, socket, head);
+      });
+      const cleanup = () => {
+        nextServer.removeListener("error", onError);
+        nextServer.removeListener("listening", onListening);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const onListening = () => {
+        cleanup();
+        server = nextServer;
+        resolve(addressForTesting());
+      };
+      nextServer.once("error", onError);
+      nextServer.once("listening", onListening);
+      nextServer.listen(0, "127.0.0.1");
+    }).finally(() => {
+      serverStartPromise = null;
+    });
+    return serverStartPromise;
+  };
+  const resolveLoopbackTarget = async (originalUrl) => {
+    const port = Number(originalUrl.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      return null;
+    }
+    const now = Date.now();
+    pruneExpiredTargets(now);
+    const cacheKey = originalUrl.toString();
+    const cached = targetCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.target;
+    }
+    const nextTarget = await Promise.resolve(
+      routing.resolver.resolveTarget({
+        port,
+        url: originalUrl.toString()
+      })
+    );
+    const target = normalizeLoopbackPreviewTarget(nextTarget);
+    targetCache.set(cacheKey, {
+      expiresAt: now + Math.max(0, cacheTtlMs),
+      target
+    });
+    return target;
+  };
+  const configureSession = async (input) => {
+    const nextSession = await resolveSession(input);
+    if (configuredSessions.has(nextSession)) {
+      return;
+    }
+    const address = await start();
+    await nextSession.setProxy({
+      mode: "fixed_servers",
+      proxyBypassRules: loopbackPreviewProxyBypassRules,
+      proxyRules: `http=${address}`
+    });
+    configuredSessions.add(nextSession);
+  };
+  const dispose = async () => {
+    targetCache.clear();
+    downstreamWebSocketServer.close();
+    const activeServer = server;
+    server = null;
+    if (!activeServer || !activeServer.listening) {
+      return;
+    }
+    await new Promise((resolve) => {
+      activeServer.close(() => resolve());
+    });
+  };
+  const handleRequest = async (request, response) => {
+    const originalUrl = resolveProxyRequestUrl(request);
+    if (!originalUrl) {
+      response.writeHead(400);
+      response.end("invalid proxy request");
+      return;
+    }
+    if (originalUrl.protocol !== "http:") {
+      response.writeHead(400);
+      response.end("unsupported proxy request");
+      return;
+    }
+    const targetContext = await resolveTargetRequestContext(originalUrl);
+    if (!targetContext.targetUrl) {
+      response.writeHead(502);
+      response.end("unable to resolve loopback preview target");
+      return;
+    }
+    const headers = filterProxyHeaders(request.headers);
+    headers.set("host", targetContext.targetUrl.host);
+    const forward = targetContext.targetUrl.protocol === "https:" ? httpsRequest : httpRequest;
+    const upstream = forward(
+      targetContext.targetUrl,
+      {
+        headers: Object.fromEntries(headers.entries()),
+        method: request.method
+      },
+      (upstreamResponse) => {
+        const responseHeaders = filterProxyHeaders(upstreamResponse.headers);
+        const location = responseHeaders.get("location");
+        if (location && targetContext.loopbackTarget) {
+          const rewritten = rewriteLoopbackLocation({
+            location,
+            originalUrl,
+            targetUrl: targetContext.loopbackTarget.targetUrl
+          });
+          if (rewritten) {
+            responseHeaders.set("location", rewritten);
+          }
+        }
+        response.writeHead(
+          upstreamResponse.statusCode ?? 502,
+          upstreamResponse.statusMessage,
+          Object.fromEntries(responseHeaders.entries())
+        );
+        pipeline(upstreamResponse, response, () => void 0);
+      }
+    );
+    upstream.on("error", (error) => {
+      logger?.warn?.("Browser Node loopback preview request failed", {
+        error: normalizeProxyError(error),
+        originalUrl: originalUrl.toString(),
+        targetUrl: targetContext.targetUrl?.toString() ?? null,
+        workspaceId: targetContext.loopbackTarget?.workspaceId ?? null
+      });
+      if (!response.headersSent) {
+        response.writeHead(502);
+      }
+      response.end(
+        `loopback preview upstream request failed: ${normalizeProxyError(error)}`
+      );
+    });
+    pipeline(request, upstream, () => void 0);
+  };
+  const handleUpgrade = async (request, socket, head) => {
+    const originalUrl = resolveProxyRequestUrl(request, "ws:");
+    if (!originalUrl) {
+      socket.destroy();
+      return;
+    }
+    if (originalUrl.protocol !== "ws:") {
+      socket.destroy();
+      return;
+    }
+    const targetContext = await resolveTargetRequestContext(originalUrl);
+    const targetUrl = targetContext.targetUrl;
+    if (!targetUrl) {
+      socket.destroy();
+      return;
+    }
+    downstreamWebSocketServer.handleUpgrade(
+      request,
+      socket,
+      head,
+      (downstream) => {
+        const headers = Object.fromEntries(
+          filterProxyHeaders(request.headers).entries()
+        );
+        headers.host = targetUrl.host;
+        const upstream = new WebSocket(targetUrl, { headers });
+        const pendingMessages = [];
+        downstream.on("message", (data, isBinary) => {
+          if (upstream.readyState === WebSocket.OPEN) {
+            upstream.send(data, { binary: isBinary });
+            return;
+          }
+          pendingMessages.push({ data, isBinary });
+        });
+        upstream.once("open", () => {
+          for (const nextMessage of pendingMessages.splice(0)) {
+            upstream.send(nextMessage.data, { binary: nextMessage.isBinary });
+          }
+        });
+        upstream.on("message", (data, isBinary) => {
+          if (downstream.readyState === WebSocket.OPEN) {
+            downstream.send(data, { binary: isBinary });
+          }
+        });
+        upstream.once("close", (code, reason) => {
+          if (downstream.readyState === WebSocket.OPEN || downstream.readyState === WebSocket.CONNECTING) {
+            downstream.close(normalizeWebSocketCloseCode(code), reason);
+          }
+        });
+        downstream.once("close", (code, reason) => {
+          if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+            upstream.close(normalizeWebSocketCloseCode(code), reason);
+          }
+        });
+        upstream.once("error", (error) => {
+          logger?.warn?.("Browser Node loopback preview websocket failed", {
+            error: normalizeProxyError(error),
+            originalUrl: originalUrl.toString(),
+            targetUrl: targetContext.targetUrl?.toString() ?? null,
+            workspaceId: targetContext.loopbackTarget?.workspaceId ?? null
+          });
+          downstream.close(1011, "loopback preview websocket upstream failed");
+        });
+      }
+    );
+  };
+  const resolveTargetRequestContext = async (originalUrl) => {
+    if (!isLoopbackUrl(originalUrl)) {
+      return {
+        loopbackTarget: null,
+        targetUrl: null
+      };
+    }
+    const loopbackTarget = await resolveLoopbackTarget(originalUrl);
+    if (loopbackTarget) {
+      return {
+        loopbackTarget,
+        targetUrl: buildTargetRequestUrl(loopbackTarget.targetUrl, originalUrl)
+      };
+    }
+    if (fallback === "direct") {
+      return {
+        loopbackTarget: null,
+        targetUrl: cloneUrl(originalUrl)
+      };
+    }
+    return {
+      loopbackTarget: null,
+      targetUrl: null
+    };
+  };
+  const addressForTesting = () => {
+    const address = server?.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Browser Node loopback preview proxy is not listening");
+    }
+    return `127.0.0.1:${address.port}`;
+  };
+  const serverForTesting = () => {
+    if (!server) {
+      throw new Error("Browser Node loopback preview proxy is not started");
+    }
+    return server;
+  };
+  return {
+    addressForTesting,
+    configureSession,
+    dispose,
+    serverForTesting
+  };
+}
+function normalizeLoopbackPreviewTarget(input) {
+  if (!input) {
+    return null;
+  }
+  const normalizedTargetUrl = input.targetUrl.trim();
+  if (normalizedTargetUrl.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = new URL(normalizedTargetUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return {
+      targetUrl: parsed.toString(),
+      workspaceId: input.workspaceId
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveProxyRequestUrl(request, defaultProtocol = "http:") {
+  const rawUrl = request.url ?? "";
+  try {
+    if (/^[a-z][a-z\d+\-.]*:\/\//i.test(rawUrl)) {
+      return new URL(rawUrl);
+    }
+    const host = request.headers.host;
+    if (typeof host !== "string" || host.trim().length === 0) {
+      return null;
+    }
+    const path = rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+    return new URL(`${defaultProtocol}//${host}${path}`);
+  } catch {
+    return null;
+  }
+}
+function filterProxyHeaders(input) {
+  const output = new Headers();
+  const appendValue = (key, value) => {
+    if (hopByHopHeaders.has(key.toLowerCase())) {
+      return;
+    }
+    output.append(key, value);
+  };
+  if (input instanceof Headers) {
+    input.forEach((value, key) => {
+      appendValue(key, value);
+    });
+    return output;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    if (Array.isArray(value)) {
+      for (const nextValue of value) {
+        appendValue(key, nextValue);
+      }
+      continue;
+    }
+    if (typeof value === "string") {
+      appendValue(key, value);
+    }
+  }
+  return output;
+}
+function isLoopbackUrl(url) {
+  return (url.protocol === "http:" || url.protocol === "ws:") && loopbackHostPattern.test(url.hostname) && url.port.length > 0;
+}
+function buildTargetRequestUrl(targetUrl, originalUrl) {
+  try {
+    const base = new URL(targetUrl);
+    const normalizedBasePath = normalizeBasePath(base.pathname);
+    const nextUrl = new URL(base.toString());
+    nextUrl.pathname = joinBasePath(normalizedBasePath, originalUrl.pathname);
+    nextUrl.search = originalUrl.search;
+    nextUrl.hash = "";
+    if (originalUrl.protocol === "ws:") {
+      nextUrl.protocol = nextUrl.protocol === "https:" ? "wss:" : "ws:";
+    }
+    return nextUrl;
+  } catch {
+    return null;
+  }
+}
+function rewriteLoopbackLocation({
+  location,
+  originalUrl,
+  targetUrl
+}) {
+  try {
+    const targetBase = new URL(targetUrl);
+    const resolvedLocation = new URL(location, targetBase);
+    if (resolvedLocation.origin !== targetBase.origin) {
+      return location;
+    }
+    const basePath = normalizeBasePath(targetBase.pathname);
+    const strippedPath = stripBasePath(basePath, resolvedLocation.pathname) ?? resolvedLocation.pathname;
+    const loopbackUrl = new URL(originalUrl.origin);
+    resolvedLocation.protocol = loopbackUrl.protocol;
+    resolvedLocation.host = loopbackUrl.host;
+    resolvedLocation.pathname = strippedPath;
+    resolvedLocation.username = "";
+    resolvedLocation.password = "";
+    return resolvedLocation.toString();
+  } catch {
+    return location;
+  }
+}
+function normalizeBasePath(pathname) {
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function joinBasePath(basePath, requestPath) {
+  const normalizedRequestPath = requestPath === "/" ? "" : requestPath.replace(/^\/+/, "");
+  return normalizedRequestPath.length > 0 ? `${basePath}${normalizedRequestPath}`.replace(/\/{2,}/g, "/") : basePath;
+}
+function stripBasePath(basePath, pathname) {
+  const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (normalizedPath === basePath.slice(0, -1)) {
+    return "/";
+  }
+  if (!normalizedPath.startsWith(basePath)) {
+    return null;
+  }
+  const suffix = normalizedPath.slice(basePath.length);
+  return suffix.length > 0 ? `/${suffix}` : "/";
+}
+function cloneUrl(url) {
+  try {
+    return new URL(url.toString());
+  } catch {
+    return null;
+  }
+}
+function normalizeProxyError(error) {
+  if (error instanceof Error) {
+    const code = typeof error.code === "string" ? ` ${error.code}` : "";
+    return `${error.message}${code}`;
+  }
+  return String(error);
+}
+function normalizeWebSocketCloseCode(code) {
+  if (code === 1e3 || code >= 3e3 && code <= 4999) {
+    return code;
+  }
+  return 1e3;
+}
+
+// src/electron-main/guestManager.ts
+var browserPreviewMaxWidth = 260;
+var browserPreviewMaxHeight = 170;
+var abortedNavigationErrorCode = -3;
+function canGuestGoBack(contents) {
+  return contents.navigationHistory?.canGoBack() ?? contents.canGoBack();
+}
+function canGuestGoForward(contents) {
+  return contents.navigationHistory?.canGoForward() ?? contents.canGoForward();
+}
+function goGuestBack(contents) {
+  if (contents.navigationHistory) {
+    contents.navigationHistory.goBack();
+    return;
+  }
+  contents.goBack();
+}
+function goGuestForward(contents) {
+  if (contents.navigationHistory) {
+    contents.navigationHistory.goForward();
+    return;
+  }
+  contents.goForward();
+}
+function getPopupLogMetadata(url) {
+  try {
+    const parsed = new URL(url);
+    return {
+      popupOrigin: parsed.origin,
+      popupPath: parsed.pathname,
+      popupProtocol: parsed.protocol
+    };
+  } catch {
+    return {
+      popupOrigin: null,
+      popupPath: null,
+      popupProtocol: null
+    };
+  }
+}
+function allowBrowserNodeGuestPopupWindow({
+  logger,
+  nodeId,
+  url,
+  webContentsId
+}) {
+  logger?.info?.("Browser Node guest popup allowed", {
+    nodeId,
+    webContentsId,
+    ...getPopupLogMetadata(url)
+  });
+  return {
+    action: "allow",
+    overrideBrowserWindowOptions: {
+      height: 720,
+      show: true,
+      width: 520
+    }
+  };
+}
+function resolveBrowserNodeUrlError(resolved) {
+  if (resolved.errorCode === "invalid-url") {
+    return { code: "invalid-url" };
+  }
+  if (resolved.errorCode === "unsupported-protocol") {
+    return {
+      code: "unsupported-protocol",
+      params: resolved.errorParams
+    };
+  }
+  return { code: "unsupported-url" };
+}
+function resizeBrowserPreviewImage(image) {
+  if (image.isEmpty?.() === true || !image.resize || !image.getSize) {
+    return image;
+  }
+  const size = image.getSize();
+  if (size.width <= 0 || size.height <= 0) {
+    return image;
+  }
+  const scale = Math.min(
+    1,
+    browserPreviewMaxWidth / size.width,
+    browserPreviewMaxHeight / size.height
+  );
+  if (scale >= 1) {
+    return image;
+  }
+  return image.resize({
+    height: Math.max(1, Math.round(size.height * scale)),
+    quality: "good",
+    width: Math.max(1, Math.round(size.width * scale))
+  });
+}
+function isAbortedNavigationError(input) {
+  return input.errorCode === abortedNavigationErrorCode || input.errorDescription === "ERR_ABORTED";
+}
+function isHttpErrorStatusCode(statusCode) {
+  return statusCode !== void 0 && statusCode >= 400;
+}
+function emitBrowserNavigationFailed(input) {
+  input.emit({
+    code: "navigation-failed",
+    diagnosticMessage: input.errorDescription,
+    nodeId: input.nodeId,
+    params: input.errorCode === void 0 ? void 0 : { errorCode: input.errorCode },
+    type: "error"
+  });
+}
+function resolveBrowserNavigationOrigin(url) {
+  const resolved = resolveBrowserNavigationUrl(url);
+  if (!resolved.url) {
+    return null;
+  }
+  try {
+    return new URL(resolved.url).origin;
+  } catch {
+    return null;
+  }
+}
+function isBrowserNavigationAllowedByPolicy(input) {
+  if (!input.policy) {
+    return true;
+  }
+  if (input.policy.mode === "same-origin") {
+    const policyOrigin = resolveBrowserNavigationOrigin(input.policy.originUrl);
+    const nextOrigin = resolveBrowserNavigationOrigin(input.url);
+    return policyOrigin !== null && nextOrigin !== null && policyOrigin === nextOrigin;
+  }
+  return true;
+}
+async function applyPreferredColorSchemeToGuest(session, logger, syncPreferredColorScheme, scheme) {
+  const contents = session.contents;
+  if (!contents || contents.isDestroyed() || !syncPreferredColorScheme || scheme === null || session.appliedColorScheme === scheme) {
+    return;
+  }
+  try {
+    await syncPreferredColorScheme(contents, scheme);
+    session.appliedColorScheme = scheme;
+  } catch (error) {
+    session.appliedColorScheme = null;
+    logger?.warn?.("Browser Node failed to sync guest color scheme", {
+      error: error instanceof Error ? error.message : String(error),
+      nodeId: session.nodeId,
+      scheme,
+      webContentsId: session.webContentsId
+    });
+  }
+}
+function createBrowserGuestManager({
+  emit,
+  getPreferredColorScheme,
+  logger,
+  openExternal,
+  prepareSession,
+  resolveWebContents,
+  syncPreferredColorScheme,
+  subscribePreferredColorScheme
+}) {
+  const sessions = /* @__PURE__ */ new Map();
+  const nodeIdByWebContentsId = /* @__PURE__ */ new Map();
+  let preferredColorScheme = getPreferredColorScheme?.() ?? null;
+  const getSession = (nodeId, input) => {
+    const existing = sessions.get(nodeId);
+    if (existing) {
+      if (input?.profileId !== void 0) {
+        existing.profileId = input.profileId;
+      }
+      if (input?.sessionMode !== void 0) {
+        existing.sessionMode = input.sessionMode;
+      }
+      if (input?.sessionPartition !== void 0) {
+        existing.sessionPartition = input.sessionPartition;
+      }
+      if (input?.navigationPolicy !== void 0) {
+        existing.navigationPolicy = input.navigationPolicy;
+      }
+      if (input?.url !== void 0) {
+        existing.desiredUrl = input.url;
+      }
+      return existing;
+    }
+    const session = {
+      appliedColorScheme: null,
+      contents: null,
+      desiredUrl: input?.url ?? "about:blank",
+      lifecycle: "cold",
+      listeners: [],
+      navigationFailureSequence: 0,
+      navigationPolicy: input?.navigationPolicy ?? null,
+      nodeId,
+      profileId: input?.profileId ?? null,
+      sessionMode: input?.sessionMode ?? "shared",
+      sessionPartition: input?.sessionPartition ?? null,
+      webContentsId: null
+    };
+    sessions.set(nodeId, session);
+    return session;
+  };
+  const publishState = (session) => {
+    const contents = session.contents && !session.contents.isDestroyed() ? session.contents : null;
+    emit({
+      canGoBack: contents ? canGuestGoBack(contents) : false,
+      canGoForward: contents ? canGuestGoForward(contents) : false,
+      isAttachedToWindow: Boolean(contents),
+      isLoading: contents ? contents.isLoading() : false,
+      isOccluded: session.lifecycle === "cold",
+      lifecycle: session.lifecycle,
+      nodeId: session.nodeId,
+      title: contents ? contents.getTitle() || null : null,
+      type: "state",
+      url: contents ? contents.getURL() || session.desiredUrl : session.desiredUrl
+    });
+  };
+  const detachGuest = (session) => {
+    const contents = session.contents;
+    const webContentsId = session.webContentsId;
+    if (contents) {
+      for (const record of session.listeners) {
+        contents.off(record.event, record.listener);
+      }
+    }
+    session.listeners = [];
+    session.contents = null;
+    session.appliedColorScheme = null;
+    session.webContentsId = null;
+    if (webContentsId !== null && nodeIdByWebContentsId.get(webContentsId) === session.nodeId) {
+      nodeIdByWebContentsId.delete(webContentsId);
+    }
+    publishState(session);
+  };
+  const handlePreferredColorSchemeChange = (scheme) => {
+    preferredColorScheme = scheme;
+    for (const session of sessions.values()) {
+      session.appliedColorScheme = null;
+      void applyPreferredColorSchemeToGuest(
+        session,
+        logger,
+        syncPreferredColorScheme,
+        scheme
+      ).catch(() => void 0);
+    }
+  };
+  const unsubscribePreferredColorScheme = subscribePreferredColorScheme?.(handlePreferredColorSchemeChange) ?? null;
+  const attachGuestListeners = (session) => {
+    const contents = session.contents;
+    if (!contents) {
+      return;
+    }
+    const onStateChange = () => publishState(session);
+    const onDidNavigate = (...args) => {
+      const url = typeof args[1] === "string" ? args[1] : void 0;
+      const statusCode = typeof args[2] === "number" ? args[2] : void 0;
+      const statusText = typeof args[3] === "string" ? args[3] : void 0;
+      publishState(session);
+      if (!isHttpErrorStatusCode(statusCode)) {
+        return;
+      }
+      logger?.warn?.("Browser Node guest navigation returned HTTP error", {
+        currentUrl: contents.getURL(),
+        desiredUrl: session.desiredUrl,
+        nodeId: session.nodeId,
+        statusCode,
+        statusText,
+        url,
+        webContentsId: session.webContentsId
+      });
+      emit({
+        code: "navigation-failed",
+        diagnosticMessage: statusText,
+        nodeId: session.nodeId,
+        params: {
+          statusCode,
+          ...statusText ? { statusText } : {}
+        },
+        type: "error"
+      });
+    };
+    const onFailLoad = (...args) => {
+      const errorCode = typeof args[1] === "number" ? args[1] : void 0;
+      const errorDescription = typeof args[2] === "string" ? args[2] : void 0;
+      const validatedUrl = typeof args[3] === "string" ? args[3] : void 0;
+      const isMainFrame = typeof args[4] === "boolean" ? args[4] : void 0;
+      if (isAbortedNavigationError({ errorCode, errorDescription })) {
+        publishState(session);
+        return;
+      }
+      logger?.warn?.("Browser Node guest navigation failed", {
+        currentUrl: contents.getURL(),
+        desiredUrl: session.desiredUrl,
+        errorCode,
+        errorDescription,
+        isMainFrame,
+        nodeId: session.nodeId,
+        validatedUrl,
+        webContentsId: session.webContentsId
+      });
+      session.navigationFailureSequence += 1;
+      publishState(session);
+      emitBrowserNavigationFailed({
+        emit,
+        errorCode,
+        errorDescription,
+        nodeId: session.nodeId
+      });
+    };
+    const onDestroyed = () => detachGuest(session);
+    const onWillNavigate = (...args) => {
+      const event = args[0] && typeof args[0] === "object" && "preventDefault" in args[0] ? args[0] : null;
+      const url = typeof args[1] === "string" ? args[1] : "";
+      if (url.length === 0 || isBrowserNavigationAllowedByPolicy({
+        policy: session.navigationPolicy,
+        url
+      })) {
+        return;
+      }
+      event?.preventDefault?.();
+      emitOpenUrlFromGuest(session, url);
+      publishState(session);
+    };
+    const records = [
+      { event: "did-start-loading", listener: onStateChange },
+      { event: "did-stop-loading", listener: onStateChange },
+      { event: "did-navigate", listener: onDidNavigate },
+      { event: "did-navigate-in-page", listener: onStateChange },
+      { event: "page-title-updated", listener: onStateChange },
+      { event: "will-navigate", listener: onWillNavigate },
+      { event: "did-fail-load", listener: onFailLoad },
+      { event: "destroyed", listener: onDestroyed }
+    ];
+    for (const record of records) {
+      contents.on(record.event, record.listener);
+    }
+    session.listeners = records;
+  };
+  const loadDesiredUrl = async (session) => {
+    const contents = session.contents;
+    if (!contents || contents.isDestroyed()) {
+      publishState(session);
+      return;
+    }
+    const resolved = resolveHostBrowserNavigationUrl(session.desiredUrl);
+    if (!resolved.url) {
+      emit({
+        ...resolveBrowserNodeUrlError(resolved),
+        nodeId: session.nodeId,
+        type: "error"
+      });
+      publishState(session);
+      return;
+    }
+    if (!isBrowserNavigationAllowedByPolicy({
+      policy: session.navigationPolicy,
+      url: resolved.url
+    })) {
+      emitOpenUrlFromGuest(session, resolved.url);
+      publishState(session);
+      return;
+    }
+    const currentComparable = normalizeHostBrowserComparableUrl(
+      contents.getURL()
+    );
+    const nextComparable = normalizeHostBrowserComparableUrl(resolved.url);
+    if (currentComparable && currentComparable === nextComparable) {
+      publishState(session);
+      return;
+    }
+    const failureSequenceBeforeLoad = session.navigationFailureSequence;
+    try {
+      await contents.loadURL(resolved.url);
+      publishState(session);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger?.warn?.("Browser Node guest loadURL failed", {
+        currentUrl: contents.getURL(),
+        desiredUrl: session.desiredUrl,
+        error: message,
+        nodeId: session.nodeId,
+        resolvedUrl: resolved.url,
+        webContentsId: session.webContentsId
+      });
+      if (session.navigationFailureSequence !== failureSequenceBeforeLoad) {
+        return;
+      }
+      publishState(session);
+      emitBrowserNavigationFailed({
+        emit,
+        errorDescription: message,
+        nodeId: session.nodeId
+      });
+    }
+  };
+  const emitOpenUrlFromGuest = (session, url) => {
+    const resolved = resolveBrowserNavigationUrl(url);
+    if (resolved.url) {
+      logger?.info?.("Browser Node guest emitted open-url", {
+        nodeId: session.nodeId,
+        url: resolved.url,
+        webContentsId: session.webContentsId
+      });
+      emit({
+        reuseIfOpen: false,
+        sourceNodeId: session.nodeId,
+        type: "open-url",
+        url: resolved.url
+      });
+      return { action: "deny" };
+    }
+    void Promise.resolve(openExternal(url)).catch((error) => {
+      logger?.warn?.("Browser Node openExternal failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    return { action: "deny" };
+  };
+  return {
+    async activate(input) {
+      const resolved = resolveHostBrowserNavigationUrl(input.url);
+      if (!resolved.url) {
+        throw new Error("Browser Node rejected navigation URL");
+      }
+      const session = getSession(input.nodeId, {
+        navigationPolicy: input.navigationPolicy,
+        profileId: input.profileId,
+        sessionMode: input.sessionMode,
+        sessionPartition: input.sessionPartition,
+        url: resolved.url
+      });
+      session.lifecycle = "active";
+      await loadDesiredUrl(session);
+    },
+    async capturePreview(input) {
+      const session = sessions.get(input.nodeId);
+      const contents = session?.contents && !session.contents.isDestroyed() ? session.contents : null;
+      if (!contents?.capturePage) {
+        return null;
+      }
+      const image = await contents.capturePage();
+      if (image.isEmpty?.() === true) {
+        return null;
+      }
+      return resizeBrowserPreviewImage(image).toDataURL();
+    },
+    close(input) {
+      const session = sessions.get(input.nodeId);
+      if (session) {
+        detachGuest(session);
+        sessions.delete(input.nodeId);
+      }
+      emit({ nodeId: input.nodeId, type: "closed" });
+      return Promise.resolve();
+    },
+    debugDump(input) {
+      const session = sessions.get(input.nodeId);
+      if (!session) {
+        return null;
+      }
+      const contents = session.contents && !session.contents.isDestroyed() ? session.contents : null;
+      return {
+        canGoBack: contents ? canGuestGoBack(contents) : false,
+        canGoForward: contents ? canGuestGoForward(contents) : false,
+        currentUrl: contents ? contents.getURL() : null,
+        desiredUrl: session.desiredUrl,
+        isAttachedToWindow: Boolean(contents),
+        isLoading: contents ? contents.isLoading() : false,
+        lifecycle: session.lifecycle,
+        nodeId: session.nodeId,
+        profileId: session.profileId,
+        sessionMode: session.sessionMode,
+        sessionPartition: session.sessionPartition,
+        title: contents ? contents.getTitle() : null,
+        userAgent: contents?.getUserAgent?.() ?? null,
+        webContentsDestroyed: session.contents ? session.contents.isDestroyed() : null,
+        webContentsId: session.webContentsId
+      };
+    },
+    goBack(input) {
+      const contents = sessions.get(input.nodeId)?.contents;
+      if (contents && !contents.isDestroyed() && canGuestGoBack(contents)) {
+        goGuestBack(contents);
+      }
+      return Promise.resolve();
+    },
+    goForward(input) {
+      const contents = sessions.get(input.nodeId)?.contents;
+      if (contents && !contents.isDestroyed() && canGuestGoForward(contents)) {
+        goGuestForward(contents);
+      }
+      return Promise.resolve();
+    },
+    handleGuestOpenUrl(webContentsId, input) {
+      const nodeId = nodeIdByWebContentsId.get(webContentsId);
+      const session = nodeId ? sessions.get(nodeId) : null;
+      if (!session) {
+        logger?.warn?.("Browser Node ignored guest open-url request", {
+          url: input.url,
+          webContentsId
+        });
+        return;
+      }
+      logger?.info?.("Browser Node handling guest open-url request", {
+        nodeId: session.nodeId,
+        url: input.url,
+        webContentsId
+      });
+      emitOpenUrlFromGuest(session, input.url);
+    },
+    async navigate(input) {
+      const resolved = resolveBrowserNavigationUrl(input.url);
+      if (!resolved.url) {
+        throw new Error("Browser Node rejected navigation URL");
+      }
+      const session = getSession(input.nodeId, {
+        navigationPolicy: input.navigationPolicy,
+        url: resolved.url
+      });
+      session.lifecycle = "active";
+      await loadDesiredUrl(session);
+    },
+    async openExternal(input) {
+      const resolved = resolveBrowserNavigationUrl(input.url);
+      if (!resolved.url) {
+        throw new Error("Browser Node rejected external URL");
+      }
+      await Promise.resolve(openExternal(resolved.url));
+    },
+    openDevTools(input) {
+      const session = sessions.get(input.nodeId);
+      const contents = session?.contents ?? null;
+      if (contents && !contents.isDestroyed()) {
+        try {
+          contents.openDevTools?.({ activate: true, mode: "detach" });
+        } catch (error) {
+          logger?.warn?.("Browser Node open devtools failed", {
+            error: error instanceof Error ? error.message : String(error),
+            nodeId: input.nodeId,
+            webContentsId: session?.webContentsId ?? null
+          });
+          throw error;
+        }
+      }
+      return Promise.resolve();
+    },
+    async prepareSession(input) {
+      await prepareSession?.(input);
+      getSession(input.nodeId, {
+        navigationPolicy: input.navigationPolicy,
+        profileId: input.profileId,
+        sessionMode: input.sessionMode,
+        sessionPartition: input.sessionPartition
+      });
+    },
+    async registerGuest(input) {
+      await prepareSession?.({
+        nodeId: input.nodeId,
+        profileId: input.profileId,
+        sessionMode: input.sessionMode,
+        sessionPartition: input.sessionPartition,
+        navigationPolicy: input.navigationPolicy
+      });
+      const contents = resolveWebContents(input.webContentsId);
+      if (!contents || contents.isDestroyed()) {
+        throw new Error(
+          `Browser Node guest ${input.webContentsId} is not available`
+        );
+      }
+      const ownerNodeId = nodeIdByWebContentsId.get(input.webContentsId);
+      if (ownerNodeId && ownerNodeId !== input.nodeId) {
+        throw new Error(
+          `Browser Node guest ${input.webContentsId} is already registered`
+        );
+      }
+      const session = getSession(input.nodeId, {
+        navigationPolicy: input.navigationPolicy,
+        profileId: input.profileId,
+        sessionMode: input.sessionMode,
+        sessionPartition: input.sessionPartition
+      });
+      if (session.webContentsId === input.webContentsId && session.contents === contents) {
+        publishState(session);
+        return;
+      }
+      if (session.contents && session.contents !== contents) {
+        detachGuest(session);
+      }
+      session.contents = contents;
+      session.webContentsId = input.webContentsId;
+      nodeIdByWebContentsId.set(input.webContentsId, input.nodeId);
+      session.lifecycle = "active";
+      logger?.info?.("Browser Node registered guest owner", {
+        nodeId: input.nodeId,
+        sessionPartition: session.sessionPartition,
+        webContentsId: input.webContentsId
+      });
+      contents.setWindowOpenHandler?.(
+        ({ url }) => allowBrowserNodeGuestPopupWindow({
+          logger,
+          nodeId: input.nodeId,
+          url,
+          webContentsId: input.webContentsId
+        })
+      );
+      attachGuestListeners(session);
+      await applyPreferredColorSchemeToGuest(
+        session,
+        logger,
+        syncPreferredColorScheme,
+        preferredColorScheme
+      );
+      await loadDesiredUrl(session);
+    },
+    reload(input) {
+      const contents = sessions.get(input.nodeId)?.contents;
+      if (contents && !contents.isDestroyed()) {
+        contents.reload();
+      }
+      return Promise.resolve();
+    },
+    unregisterGuest(input) {
+      const session = sessions.get(input.nodeId);
+      if (!session || session.webContentsId !== input.webContentsId) {
+        return Promise.resolve();
+      }
+      session.lifecycle = "cold";
+      detachGuest(session);
+      return Promise.resolve();
+    },
+    dispose() {
+      unsubscribePreferredColorScheme?.();
+    }
+  };
+}
+
+// src/electron-main/registerElectronMain.ts
+function registerBrowserNodeElectronMain(input) {
+  const managersByWindow = /* @__PURE__ */ new WeakMap();
+  const loopbackPreviewProxy = input.loopbackPreviewRouting !== void 0 ? createBrowserNodeLoopbackPreviewProxy({
+    logger: input.logger,
+    resolveSession: async ({
+      profileId,
+      sessionMode,
+      sessionPartition
+    }) => {
+      const { session } = await import("electron");
+      return session.fromPartition(
+        resolveBrowserSessionPartition({
+          profileId,
+          sessionMode,
+          sessionPartition
+        })
+      );
+    },
+    routing: input.loopbackPreviewRouting
+  }) : null;
+  const resolveManagerForWindow = (event, ownerWindow) => {
+    const existing = managersByWindow.get(ownerWindow);
+    if (existing) {
+      return existing;
+    }
+    const manager = createBrowserGuestManager({
+      emit(browserEvent) {
+        if (!ownerWindow.isDestroyed()) {
+          ownerWindow.webContents.send(input.channels.event, browserEvent);
+        }
+      },
+      getPreferredColorScheme: input.getPreferredColorScheme,
+      logger: input.logger,
+      openExternal: input.openExternal,
+      prepareSession: loopbackPreviewProxy !== null ? (payload) => loopbackPreviewProxy.configureSession(payload) : void 0,
+      resolveWebContents: (webContentsId) => input.resolveWebContents({
+        event,
+        ownerWindow,
+        webContentsId
+      }),
+      syncPreferredColorScheme: input.syncPreferredColorScheme,
+      subscribePreferredColorScheme: input.subscribePreferredColorScheme
+    });
+    ownerWindow.once("closed", () => {
+      manager.dispose();
+      managersByWindow.delete(ownerWindow);
+    });
+    managersByWindow.set(ownerWindow, manager);
+    return manager;
+  };
+  const resolveOwnedManager = (event) => {
+    const ownerWindow = input.getOwnerWindow(event);
+    if (!ownerWindow) {
+      throw new Error("Browser Node IPC requires an owner window");
+    }
+    return {
+      manager: resolveManagerForWindow(event, ownerWindow),
+      ownerWindow
+    };
+  };
+  const showDevToolsContextMenu = input.showDevToolsContextMenu ?? showElectronDevToolsContextMenu;
+  input.registerHandler(
+    input.channels.prepareSession,
+    (event, payload) => resolveOwnedManager(event).manager.prepareSession(
+      payload
+    )
+  );
+  input.registerHandler(
+    input.channels.activate,
+    (event, payload) => resolveOwnedManager(event).manager.activate(
+      payload
+    )
+  );
+  if (input.channels.capturePreview) {
+    input.registerHandler(
+      input.channels.capturePreview,
+      (event, payload) => resolveOwnedManager(event).manager.capturePreview(
+        payload
+      )
+    );
+  }
+  input.registerHandler(
+    input.channels.registerGuest,
+    (event, payload) => resolveOwnedManager(event).manager.registerGuest(
+      payload
+    )
+  );
+  input.registerHandler(
+    input.channels.unregisterGuest,
+    (event, payload) => resolveOwnedManager(event).manager.unregisterGuest(
+      payload
+    )
+  );
+  input.registerHandler(
+    input.channels.navigate,
+    (event, payload) => resolveOwnedManager(event).manager.navigate(
+      payload
+    )
+  );
+  if (input.channels.openExternal) {
+    input.registerHandler(
+      input.channels.openExternal,
+      (event, payload) => resolveOwnedManager(event).manager.openExternal(
+        payload
+      )
+    );
+  }
+  if (input.channels.openDevTools) {
+    input.registerHandler(input.channels.openDevTools, (event, payload) => {
+      const nodePayload = payload;
+      return resolveOwnedManager(event).manager.openDevTools(nodePayload);
+    });
+  }
+  if (input.channels.showDevToolsContextMenu) {
+    input.registerHandler(
+      input.channels.showDevToolsContextMenu,
+      (event, payload) => {
+        const contextMenuPayload = payload;
+        const { manager, ownerWindow } = resolveOwnedManager(event);
+        return showDevToolsContextMenu({
+          label: contextMenuPayload.label,
+          openDevTools: () => {
+            return manager.openDevTools({ nodeId: contextMenuPayload.nodeId });
+          },
+          ownerWindow,
+          point: contextMenuPayload.point
+        });
+      }
+    );
+  }
+  input.registerHandler(
+    input.channels.goBack,
+    (event, payload) => resolveOwnedManager(event).manager.goBack(payload)
+  );
+  input.registerHandler(
+    input.channels.goForward,
+    (event, payload) => resolveOwnedManager(event).manager.goForward(
+      payload
+    )
+  );
+  input.registerHandler(
+    input.channels.reload,
+    (event, payload) => resolveOwnedManager(event).manager.reload(payload)
+  );
+  input.registerHandler(
+    input.channels.close,
+    (event, payload) => resolveOwnedManager(event).manager.close(payload)
+  );
+  if (input.channels.debugDump) {
+    input.registerHandler(
+      input.channels.debugDump,
+      (event, payload) => resolveOwnedManager(event).manager.debugDump(
+        payload
+      )
+    );
+  }
+  if (input.channels.guestOpenUrl && input.registerListener) {
+    input.registerListener(input.channels.guestOpenUrl, (event, payload) => {
+      const senderId = readBrowserNodeIpcSenderId(event);
+      const openUrlPayload = payload;
+      if (typeof senderId !== "number" || !Number.isFinite(senderId) || !openUrlPayload || typeof openUrlPayload.url !== "string") {
+        return;
+      }
+      resolveOwnedManager(event).manager.handleGuestOpenUrl(
+        senderId,
+        openUrlPayload
+      );
+    });
+  }
+}
+async function showElectronDevToolsContextMenu(input) {
+  const { Menu } = await import("electron");
+  const menu = Menu.buildFromTemplate([
+    {
+      click: () => {
+        void Promise.resolve(input.openDevTools()).catch(() => void 0);
+      },
+      label: input.label
+    }
+  ]);
+  menu.popup({
+    window: input.ownerWindow,
+    x: Math.round(input.point.x),
+    y: Math.round(input.point.y)
+  });
+}
+function readBrowserNodeIpcSenderId(event) {
+  const sender = event?.sender;
+  return typeof sender?.id === "number" ? sender.id : null;
+}
+
+// src/electron-main/userAgent.ts
+var electronUserAgentTokenPattern = /\sElectron\/[^\s]+/g;
+function sanitizeBrowserGuestUserAgent(userAgent) {
+  return userAgent.trim().replace(electronUserAgentTokenPattern, "").replace(/\s{2,}/g, " ");
+}
+function applyBrowserGuestUserAgent(contents, logger) {
+  const guestContents = contents;
+  if (typeof guestContents.getUserAgent !== "function" || typeof guestContents.setUserAgent !== "function") {
+    return;
+  }
+  const currentUserAgent = guestContents.getUserAgent().trim();
+  const nextUserAgent = sanitizeBrowserGuestUserAgent(currentUserAgent);
+  if (!nextUserAgent || nextUserAgent === currentUserAgent) {
+    return;
+  }
+  guestContents.setUserAgent(nextUserAgent);
+  logger?.debug?.("Browser Node sanitized guest user agent", {
+    webContentsId: contents.id ?? null
+  });
+}
+
+// src/electron-main/webviewSecurity.ts
+function isBrowserNodeInitialWebviewUrl(url) {
+  return (url ?? "").trim() === "about:blank";
+}
+function isBrowserNodeWebviewAttach(params, allowedSessionPartitions) {
+  return params["data-browser-node-webview"] === "true" || isBrowserSessionPartitionAllowed(params.partition, allowedSessionPartitions);
+}
+function shouldAllowBrowserNodeNativePopups(params) {
+  return params["data-browser-node-webview"] === "true" || isBrowserSessionPartitionAllowed(params.partition);
+}
+function getPopupLogMetadata2(url) {
+  try {
+    const parsed = new URL(url);
+    return {
+      popupOrigin: parsed.origin,
+      popupPath: parsed.pathname,
+      popupProtocol: parsed.protocol
+    };
+  } catch {
+    return {
+      popupOrigin: null,
+      popupPath: null,
+      popupProtocol: null
+    };
+  }
+}
+function allowBrowserNodeNativePopupWindow({
+  guestWebContentsId,
+  logger,
+  url
+}) {
+  logger?.info?.("Browser Node native popup allowed", {
+    guestWebContentsId,
+    ...getPopupLogMetadata2(url)
+  });
+  return {
+    action: "allow",
+    overrideBrowserWindowOptions: {
+      height: 720,
+      show: true,
+      width: 520
+    }
+  };
+}
+function enforceBrowserWebviewSecurity({
+  allowedSessionPartitions,
+  params,
+  resolvePreload,
+  webPreferences
+}) {
+  webPreferences.allowRunningInsecureContent = false;
+  webPreferences.contextIsolation = true;
+  webPreferences.javascript = true;
+  webPreferences.nodeIntegration = false;
+  webPreferences.plugins = false;
+  webPreferences.sandbox = true;
+  webPreferences.webSecurity = true;
+  delete webPreferences.preload;
+  const partition = params.partition;
+  if (!partition || !isBrowserSessionPartitionAllowed(partition, allowedSessionPartitions)) {
+    return {
+      allowed: false,
+      reason: "Unsupported Browser Node session partition"
+    };
+  }
+  if (isBrowserNodeInitialWebviewUrl(params.src)) {
+    params.src = "about:blank";
+  } else {
+    const resolved = resolveBrowserNavigationUrl(params.src ?? "about:blank");
+    if (!resolved.url) {
+      return {
+        allowed: false,
+        reason: "Unsupported browser URL"
+      };
+    }
+    params.src = resolved.url;
+  }
+  const preload = resolvePreload?.({ params: { ...params } });
+  const resolvedPreload = typeof preload === "string" ? preload.trim() : "";
+  if (resolvedPreload.length > 0) {
+    webPreferences.preload = resolvedPreload;
+  }
+  return { allowed: true, reason: null };
+}
+function installBrowserWebviewSecurity({
+  allowedSessionPartitions,
+  contents,
+  logger,
+  onGuestAttached,
+  openExternal,
+  resolvePreload,
+  shouldHandleWebview
+}) {
+  const pendingBrowserAttaches = [];
+  const handleWillAttachWebview = (event, webPreferences, params) => {
+    const shouldHandle = shouldHandleWebview?.(params) ?? isBrowserNodeWebviewAttach(params, allowedSessionPartitions);
+    logger?.debug?.("Browser Node webview will attach", {
+      partition: params.partition ?? null,
+      shouldHandle,
+      src: params.src ?? null
+    });
+    if (!shouldHandle) {
+      return;
+    }
+    const allowNativePopups = shouldAllowBrowserNodeNativePopups(params);
+    if (allowNativePopups) {
+      params.allowpopups = "true";
+    }
+    logger?.info?.("Browser Node webview popup policy applied", {
+      allowNativePopups,
+      allowpopups: params.allowpopups ?? null,
+      partition: params.partition ?? null,
+      src: params.src ?? null
+    });
+    const result = enforceBrowserWebviewSecurity({
+      allowedSessionPartitions,
+      params,
+      resolvePreload,
+      webPreferences
+    });
+    if (!result.allowed) {
+      logger?.warn?.("Browser Node webview blocked", { reason: result.reason });
+      event.preventDefault();
+      return;
+    }
+    pendingBrowserAttaches.push({
+      allowNativePopups
+    });
+    logger?.debug?.("Browser Node webview attach allowed", {
+      partition: params.partition ?? null,
+      src: params.src ?? null
+    });
+  };
+  const handleDidAttachWebview = (_event, guestContents) => {
+    const pendingAttach = pendingBrowserAttaches.shift();
+    if (!pendingAttach) {
+      logger?.debug?.("Browser Node webview did attach ignored", {
+        guestWebContentsId: guestContents.id ?? null,
+        pendingBrowserAttachCount: pendingBrowserAttaches.length
+      });
+      return;
+    }
+    applyBrowserGuestUserAgent(guestContents, logger);
+    if (pendingAttach.allowNativePopups) {
+      guestContents.setWindowOpenHandler(
+        ({ url }) => allowBrowserNodeNativePopupWindow({
+          guestWebContentsId: guestContents.id ?? null,
+          logger,
+          url
+        })
+      );
+    } else {
+      guestContents.setWindowOpenHandler(({ url }) => {
+        logger?.info?.("Browser Node webview popup externalized", {
+          guestWebContentsId: guestContents.id ?? null,
+          ...getPopupLogMetadata2(url)
+        });
+        const resolved = resolveBrowserNavigationUrl(url);
+        if (resolved.url) {
+          void Promise.resolve(openExternal(resolved.url)).catch(
+            () => void 0
+          );
+        }
+        return { action: "deny" };
+      });
+    }
+    onGuestAttached?.(guestContents);
+    logger?.debug?.("Browser Node webview guest attached", {
+      guestWebContentsId: guestContents.id ?? null,
+      pendingBrowserAttachCount: pendingBrowserAttaches.length
+    });
+  };
+  contents.on("will-attach-webview", handleWillAttachWebview);
+  contents.on("did-attach-webview", handleDidAttachWebview);
+  return () => {
+    contents.off("will-attach-webview", handleWillAttachWebview);
+    contents.off("did-attach-webview", handleDidAttachWebview);
+  };
+}
+export {
+  applyBrowserGuestUserAgent,
+  enforceBrowserWebviewSecurity,
+  installBrowserWebviewSecurity,
+  isBrowserNodeWebviewAttach,
+  registerBrowserNodeElectronMain,
+  sanitizeBrowserGuestUserAgent
+};
+//# sourceMappingURL=index.js.map