@amalgm/browser 0.1.2-preview.35541635545 → 0.1.2-preview.37254096068

package/dist/src/electron.cjs

@@ -808,356 +808,18 @@ var require_cjs = __commonJS({
 var electron_exports = {};
 __export(electron_exports, {
   BROWSER_IPC: () => BROWSER_IPC,
-  BROWSER_SESSION_PARTITION: () => BROWSER_SESSION_PARTITION,
-  BROWSER_SURFACE_PROTOCOL: () => BROWSER_SURFACE_PROTOCOL,
-  BROWSER_SURFACE_PROTOCOLS: () => BROWSER_SURFACE_PROTOCOLS,
-  ELECTRON_COOKIE_ADAPTER_ID: () => ELECTRON_COOKIE_ADAPTER_ID,
-  ElectronBrowserDriver: () => ElectronBrowserDriver,
-  ElectronCookieAdapter: () => ElectronCookieAdapter,
-  NativeAdBlocker: () => NativeAdBlocker,
-  adBlockHostname: () => adBlockHostname,
-  browserNavigationPolicy: () => browserNavigationPolicy,
-  codeFor: () => codeFor,
   createBrowserShell: () => createBrowserShell,
-  createBrowserSurfaceController: () => createBrowserSurfaceController,
-  getBrowserSession: () => getBrowserSession,
-  insertTextScript: () => insertTextScript,
-  isAdBlockCacheFresh: () => isAdBlockCacheFresh,
-  isAllowedExternalUrl: () => isAllowedExternalUrl,
-  isAllowedWebUrl: () => isAllowedWebUrl,
-  isLoopbackCdpUrl: () => isLoopbackCdpUrl,
-  isNativeAdBlockDisabled: () => isNativeAdBlockDisabled,
-  isolatedBrowserSession: () => isolatedBrowserSession,
-  keyScript: () => keyScript,
-  markerUrl: () => markerUrl,
-  nextAvailableDownloadPath: () => nextAvailableDownloadPath,
-  normalizeBrowserLocation: () => normalizeBrowserLocation,
-  parseUrl: () => parseUrl,
-  permissionOrigin: () => permissionOrigin,
-  removeHostAdvertisement: () => removeHostAdvertisement,
-  safeDownloadFilename: () => safeDownloadFilename,
-  safeDownloadName: () => safeDownloadName,
-  setValueScript: () => setValueScript,
-  shouldOpenAsTab: () => shouldOpenAsTab,
-  surfaceStamp: () => surfaceStamp,
-  writeHostAdvertisement: () => writeHostAdvertisement
+  createHttpCookieStore: () => createHttpCookieStore,
+  readCookieAdapter: () => readCookieAdapter
 });
 module.exports = __toCommonJS(electron_exports);
 
-// src/errors.ts
-var BrowserError = class extends Error {
-  constructor(code, message, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-  }
-  code;
-  details;
-  name = "BrowserError";
-};
-
-// src/drivers/electron/contracts.ts
-var BROWSER_SESSION_PARTITION = "persist:amalgm-browser";
-var BROWSER_SURFACE_PROTOCOL = 6;
-var BROWSER_SURFACE_PROTOCOLS = [5, BROWSER_SURFACE_PROTOCOL];
-function surfaceStamp(sessionId) {
-  return `amalgm-browser:${sessionId}`;
-}
-function markerUrl(sessionId) {
-  return `about:blank#amalgm-bsid-${encodeURIComponent(sessionId)}`;
-}
-
-// src/drivers/electron/driver.ts
-var ElectronBrowserDriver = class {
-  constructor(host) {
-    this.host = host;
-    this.capabilities = [...host.capabilities];
-  }
-  host;
-  kind = "electron";
-  capabilities;
-  identities = /* @__PURE__ */ new Map();
-  async open(input) {
-    const identity = await this.bind(input);
-    this.identities.set(input.session.id, identity);
-  }
-  async execute(input, action) {
-    let identity;
-    try {
-      identity = await this.verified(input);
-    } catch (error2) {
-      const previous = this.identities.get(input.session.id);
-      if (!previous || !isMissingSurface(error2)) throw error2;
-      identity = await this.reattachOnce(input, previous);
-    }
-    try {
-      return await this.host.execute({ identity, action, context: input.context });
-    } catch (error2) {
-      if (!isSurfaceLoss(error2)) throw error2;
-      identity = await this.reattachOnce(input, identity);
-      return this.host.execute({ identity, action, context: input.context });
-    }
-  }
-  async close(input) {
-    const identity = this.identities.get(input.session.id);
-    this.identities.delete(input.session.id);
-    if (identity) await this.host.retire(identity);
-  }
-  async saveState(input) {
-    const identity = await this.verified(input);
-    if (!this.host.saveState) throw new BrowserError("CAPABILITY_UNSUPPORTED", "Electron host cannot save auth state.");
-    return this.host.saveState(identity);
-  }
-  async loadState(input, state) {
-    const identity = await this.verified(input);
-    if (!this.host.loadState) throw new BrowserError("CAPABILITY_UNSUPPORTED", "Electron host cannot load auth state.");
-    await this.host.loadState(identity, state);
-  }
-  async startScreencast(input, onFrame) {
-    const identity = await this.verified(input);
-    if (!this.host.startScreencast) throw new BrowserError("CAPABILITY_UNSUPPORTED", "Electron host cannot record its page.");
-    return this.host.startScreencast(identity, onFrame, input.context.signal);
-  }
-  async bind(input) {
-    const identity = await this.host.requestSurface({
-      session: input.session,
-      markerUrl: markerUrl(input.session.id),
-      stamp: surfaceStamp(input.session.id),
-      context: input.context
-    });
-    assertIdentity(identity, input.session.id);
-    return identity;
-  }
-  async verified(input) {
-    const identity = this.identities.get(input.session.id);
-    if (!identity) throw new BrowserError(
-      "SURFACE_IDENTITY_FAILED",
-      "Visible surface is not bound.",
-      { reason: "unbound" }
-    );
-    const state = await this.host.inspect(identity);
-    if (!state) throw new BrowserError(
-      "SURFACE_IDENTITY_FAILED",
-      "Visible surface was lost.",
-      { reason: "lost" }
-    );
-    if (!sameIdentity(state.identity, identity)) {
-      throw new BrowserError(
-        "SURFACE_IDENTITY_FAILED",
-        "Visible surface identity did not match.",
-        { reason: "mismatch" }
-      );
-    }
-    return identity;
-  }
-  async reattachOnce(input, previous) {
-    const next = await this.bind(input);
-    if (next.surfaceId !== previous.surfaceId && next.stamp !== previous.stamp) {
-      throw new BrowserError("SURFACE_IDENTITY_FAILED", "Visible surface reattachment returned an unrelated page.");
-    }
-    this.identities.set(input.session.id, next);
-    return next;
-  }
-};
-function assertIdentity(identity, sessionId) {
-  if (identity.browserSessionId !== sessionId || identity.stamp !== surfaceStamp(sessionId) || !BROWSER_SURFACE_PROTOCOLS.includes(identity.protocol)) {
-    throw new BrowserError("SURFACE_IDENTITY_FAILED", "Electron host returned an incompatible surface identity.");
-  }
-}
-function sameIdentity(left, right) {
-  return left.surfaceId === right.surfaceId && left.browserSessionId === right.browserSessionId && left.stamp === right.stamp && left.protocol === right.protocol;
-}
-function isSurfaceLoss(error2) {
-  return error2 instanceof BrowserError && error2.code === "SURFACE_IDENTITY_FAILED" && error2.details?.reason === "lost";
-}
-function isMissingSurface(error2) {
-  return error2 instanceof BrowserError && error2.code === "SURFACE_IDENTITY_FAILED" && error2.details?.reason === "lost";
-}
-
-// src/drivers/electron/cookie-adapter.ts
-var ELECTRON_COOKIE_ADAPTER_ID = "electron:default-session";
-var ElectronCookieAdapter = class {
-  constructor(cookies) {
-    this.cookies = cookies;
-  }
-  cookies;
-  id = ELECTRON_COOKIE_ADAPTER_ID;
-  supportsPartitionedCookies = false;
-  async read() {
-    return (await this.cookies.get({})).map(fromElectron);
-  }
-  async apply(input) {
-    input.signal?.throwIfAborted();
-    for (const cookie of input.upserts) {
-      input.signal?.throwIfAborted();
-      if (!cookie.partitionKey) await this.cookies.set(toElectron(cookie));
-    }
-    for (const cookie of input.deletes || []) {
-      input.signal?.throwIfAborted();
-      if (cookie.partitionKey) continue;
-      await Promise.all([
-        this.cookies.remove(cookieUrl(cookie.domain, cookie.path, false), cookie.name),
-        this.cookies.remove(cookieUrl(cookie.domain, cookie.path, true), cookie.name)
-      ]);
-    }
-  }
-  subscribe(changed) {
-    const listener = (_event, _cookie, _cause, _removed) => changed();
-    this.cookies.on("changed", listener);
-    return () => this.cookies.off("changed", listener);
-  }
-};
-function fromElectron(cookie) {
-  return {
-    name: cookie.name,
-    value: cookie.value,
-    domain: cookie.domain || "",
-    path: cookie.path || "/",
-    ...typeof cookie.expirationDate === "number" && cookie.expirationDate >= 0 ? { expires: cookie.expirationDate } : {},
-    httpOnly: Boolean(cookie.httpOnly),
-    secure: Boolean(cookie.secure),
-    sameSite: cookie.sameSite === "strict" ? "Strict" : cookie.sameSite === "no_restriction" ? "None" : "Lax"
-  };
-}
-function toElectron(cookie) {
-  const hostOnly = !cookie.domain.startsWith(".");
-  return {
-    url: cookieUrl(cookie.domain, cookie.path, Boolean(cookie.secure) || cookie.sameSite === "None"),
-    name: cookie.name,
-    value: cookie.value,
-    path: cookie.path || "/",
-    secure: Boolean(cookie.secure),
-    httpOnly: Boolean(cookie.httpOnly),
-    sameSite: cookie.sameSite === "Strict" ? "strict" : cookie.sameSite === "None" ? "no_restriction" : "lax",
-    ...!hostOnly ? { domain: cookie.domain } : {},
-    ...typeof cookie.expires === "number" ? { expirationDate: cookie.expires } : {}
-  };
-}
-function cookieUrl(domain, path6, secure) {
-  const host = domain.trim().toLowerCase().replace(/^\.+/, "");
-  const normalizedPath = String(path6 || "/").startsWith("/") ? path6 || "/" : `/${path6}`;
-  return `${secure ? "https" : "http"}://${host}${normalizedPath}`;
-}
-
-// src/drivers/electron/advertisement.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-
-// node_modules/@amalgm/core/dist/transport/auth.js
-var utf8 = new TextEncoder();
-var RUNTIME_TOKEN_HEADER = "x-amalgm-runtime-token";
-var LOOPBACK_ORIGIN_HOSTNAMES = ["localhost", "127.0.0.1", "[::1]", "::1"];
-var RUNTIME_CORS_ALLOWED_HEADERS = [
-  "Content-Type",
-  "Authorization",
-  "Accept",
-  "Cache-Control",
-  "Last-Event-ID",
-  "Mcp-Session-Id",
-  "X-Amalgm-Session-Id",
-  RUNTIME_TOKEN_HEADER
-].join(", ");
-
-// node_modules/@amalgm/core/dist/transport/state/api.js
-var encoder = new TextEncoder();
-
-// node_modules/@amalgm/core/dist/transport/diagnostics.js
-var DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES = 256 * 1024;
-var MAX_DIAGNOSTIC_LOG_TAIL_BYTES = 2 * 1024 * 1024;
-
-// src/drivers/electron/advertisement.ts
-function writeHostAdvertisement(options) {
-  const protocol = options.protocol || BROWSER_SURFACE_PROTOCOL;
-  const pid = options.pid || process.pid;
-  if (!isLoopbackCdpUrl(options.cdpUrl)) {
-    throw new BrowserError("INVALID_INPUT", "Electron Browser CDP advertisement must use loopback.");
-  }
-  const data = {
-    browserSurfaceProtocol: protocol,
-    browserSurfaceTargetType: protocol === 5 ? "webview" : "page",
-    browserSurfaceTargetTypes: protocol === 5 ? ["webview"] : ["page", "webview"],
-    cdp: { url: options.cdpUrl, port: options.cdpPort },
-    ...protocol === 5 ? { cdpUrl: options.cdpUrl, cdpPort: options.cdpPort } : {},
-    ...options.label ? { label: options.label } : {},
-    pid,
-    startedAt: options.startedAt || (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const temporary = `${options.file}.${pid}.${Date.now()}.tmp`;
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(options.file), { recursive: true, mode: 448 });
-  try {
-    import_node_fs.default.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}
-`, { mode: 384 });
-    import_node_fs.default.renameSync(temporary, options.file);
-    import_node_fs.default.chmodSync(options.file, 384);
-  } catch (error2) {
-    import_node_fs.default.rmSync(temporary, { force: true });
-    throw error2;
-  }
-}
-function removeHostAdvertisement(file, pid = process.pid) {
-  try {
-    const value = JSON.parse(import_node_fs.default.readFileSync(file, "utf8"));
-    if (value.pid !== pid) return false;
-  } catch (error2) {
-    if (error2.code === "ENOENT") return false;
-  }
-  import_node_fs.default.rmSync(file, { force: true });
-  return true;
-}
-function isLoopbackCdpUrl(value) {
-  try {
-    const url = new URL(value);
-    return ["http:", "https:", "ws:", "wss:"].includes(url.protocol) && LOOPBACK_ORIGIN_HOSTNAMES.includes(url.hostname);
-  } catch {
-    return false;
-  }
-}
-
-// src/drivers/electron/session.ts
-function isolatedBrowserSession(sessionModule) {
-  return sessionModule.fromPartition(BROWSER_SESSION_PARTITION);
-}
-
-// src/drivers/electron/policy.ts
-var WEB_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
-var EXTERNAL_PROTOCOLS = /* @__PURE__ */ new Set(["mailto:", "tel:", "sms:"]);
-function normalizeBrowserLocation(raw) {
-  const value = raw.trim();
-  if (!value) return "about:blank";
-  if (/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(value)) return value;
-  if (/^(localhost|\d{1,3}(?:\.\d{1,3}){3})(:\d+)?(?:\/|$)/i.test(value)) return `http://${value}`;
-  if (/^[^\s.]+\.[^\s]+/.test(value)) return `https://${value}`;
-  return `https://www.google.com/search?q=${encodeURIComponent(value)}`;
-}
-function browserNavigationPolicy(raw) {
-  try {
-    const url = new URL(raw);
-    if (WEB_PROTOCOLS.has(url.protocol) || url.protocol === "about:") return "allow";
-    if (EXTERNAL_PROTOCOLS.has(url.protocol)) return "external";
-  } catch {
-  }
-  return "deny";
-}
-function safeDownloadName(value) {
-  const name = value.replace(/[\\/:*?"<>|\u0000-\u001f]/g, "_").replace(/^\.+/, "").trim();
-  return name.slice(0, 180) || "download";
-}
-function permissionOrigin(url) {
-  try {
-    const value = new URL(url);
-    return WEB_PROTOCOLS.has(value.protocol) ? value.origin : null;
-  } catch {
-    return null;
-  }
-}
-
-// src/drivers/electron/native/shell.ts
-var import_node_path4 = __toESM(require("node:path"), 1);
-var import_electron11 = require("electron");
+// src/electron/shell.ts
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_electron10 = require("electron");
 
-// src/drivers/electron/native/contracts.ts
+// src/electron/contracts.ts
 var BROWSER_IPC = {
-  registerGuest: "browser:register-guest",
   surfaceCreate: "browser:surface-create",
   surfaceUpdate: "browser:surface-update",
   surfaceDestroy: "browser:surface-destroy",
@@ -11824,12 +11486,12 @@ var utf8d = new Uint8Array([
   /* eslint-enable prettier/prettier */
 ]);
 
-// src/drivers/electron/native/adblock/index.ts
-var import_node_path3 = __toESM(require("node:path"), 1);
-
-// src/drivers/electron/native/adblock/cache.ts
-var import_node_fs2 = __toESM(require("node:fs"), 1);
+// src/electron/adblock/index.ts
 var import_node_path2 = __toESM(require("node:path"), 1);
+
+// src/electron/adblock/cache.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
 var MAX_AGE_MS = 7 * 24 * 60 * 6e4;
 var DOWNLOAD_TIMEOUT_MS = 15e3;
 function isAdBlockCacheFresh(mtimeMs, now = Date.now()) {
@@ -11858,25 +11520,25 @@ async function loadAdBlockEngine(cachePath, fetchImpl) {
 }
 async function readCache(file) {
   try {
-    const [data, stat] = await Promise.all([import_node_fs2.default.promises.readFile(file), import_node_fs2.default.promises.stat(file)]);
+    const [data, stat] = await Promise.all([import_node_fs.default.promises.readFile(file), import_node_fs.default.promises.stat(file)]);
     return { data, mtimeMs: stat.mtimeMs };
   } catch {
     return null;
   }
 }
 async function writeAtomic(file, data) {
-  await import_node_fs2.default.promises.mkdir(import_node_path2.default.dirname(file), { recursive: true, mode: 448 });
+  await import_node_fs.default.promises.mkdir(import_node_path.default.dirname(file), { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
   try {
-    await import_node_fs2.default.promises.writeFile(temporary, data, { mode: 384 });
-    await import_node_fs2.default.promises.rename(temporary, file);
+    await import_node_fs.default.promises.writeFile(temporary, data, { mode: 384 });
+    await import_node_fs.default.promises.rename(temporary, file);
   } catch (error2) {
-    await import_node_fs2.default.promises.rm(temporary, { force: true });
+    await import_node_fs.default.promises.rm(temporary, { force: true });
     throw error2;
   }
 }
 
-// src/drivers/electron/native/adblock/cosmetics.ts
+// src/electron/adblock/cosmetics.ts
 var import_electron = require("electron");
 var import_tldts_experimental3 = __toESM(require_cjs(), 1);
 var COSMETIC_INJECTION_CHANNEL = "@ghostery/adblocker/inject-cosmetic-filters";
@@ -11918,8 +11580,8 @@ function installCosmeticHandlers(input) {
   };
 }
 
-// src/drivers/electron/native/adblock/settings.ts
-var import_node_fs3 = __toESM(require("node:fs"), 1);
+// src/electron/adblock/settings.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 var AdBlockAllowlist = class {
   constructor(file) {
     this.file = file;
@@ -11946,7 +11608,7 @@ var AdBlockAllowlist = class {
 };
 function read(file) {
   try {
-    const value = JSON.parse(import_node_fs3.default.readFileSync(file, "utf8"));
+    const value = JSON.parse(import_node_fs2.default.readFileSync(file, "utf8"));
     return new Set(Array.isArray(value.pausedHosts) ? value.pausedHosts.filter((item) => typeof item === "string").map(normalize).filter(Boolean) : []);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -11956,7 +11618,7 @@ function normalize(value) {
   return value.trim().toLowerCase();
 }
 
-// src/drivers/electron/native/adblock/policy.ts
+// src/electron/adblock/policy.ts
 function adBlockHostname(value) {
   try {
     return new URL(value).hostname.toLowerCase();
@@ -11968,7 +11630,7 @@ function isNativeAdBlockDisabled(value = process.env.AMALGM_BROWSER_ADBLOCK) {
   return /^(0|false|no|off)$/i.test(String(value || "").trim());
 }
 
-// src/drivers/electron/native/adblock/index.ts
+// src/electron/adblock/index.ts
 var NativeAdBlocker = class {
   constructor(options) {
     this.options = options;
@@ -11988,7 +11650,7 @@ var NativeAdBlocker = class {
   disabled;
   cosmeticPreloadPath() {
     const generatedName = true ? "electron-preload.cjs" : "preload.js";
-    return this.disabled ? null : this.options.preloadPath || import_node_path3.default.join(__dirname, generatedName);
+    return this.disabled ? null : this.options.preloadPath || import_node_path2.default.join(__dirname, generatedName);
   }
   install(session2) {
     if (this.installed === session2) return;
@@ -12125,15 +11787,10 @@ var NativeAdBlocker = class {
   }
 };
 
-// src/drivers/electron/native/config.ts
-function nativeBrowserSurfacesEnabled(value = process.env.AMALGM_BROWSER_WCV) {
-  return !/^(0|false|no|off)$/i.test(String(value || "").trim());
-}
-
-// src/drivers/electron/native/policy.ts
+// src/electron/policy.ts
 var import_path = __toESM(require("path"), 1);
-var WEB_PROTOCOLS2 = /* @__PURE__ */ new Set(["http:", "https:", "about:"]);
-var EXTERNAL_PROTOCOLS2 = /* @__PURE__ */ new Set(["mailto:", "tel:"]);
+var WEB_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "about:"]);
+var EXTERNAL_PROTOCOLS = /* @__PURE__ */ new Set(["mailto:", "tel:"]);
 function parseUrl(value) {
   try {
     return new URL(value);
@@ -12143,13 +11800,13 @@ function parseUrl(value) {
 }
 function isAllowedWebUrl(value) {
   const parsed = parseUrl(value);
-  return Boolean(parsed && WEB_PROTOCOLS2.has(parsed.protocol));
+  return Boolean(parsed && WEB_PROTOCOLS.has(parsed.protocol));
 }
 function isAllowedExternalUrl(value) {
   const parsed = parseUrl(value);
-  return Boolean(parsed && EXTERNAL_PROTOCOLS2.has(parsed.protocol));
+  return Boolean(parsed && EXTERNAL_PROTOCOLS.has(parsed.protocol));
 }
-function permissionOrigin2(requestingUrl, fallbackUrl) {
+function permissionOrigin(requestingUrl, fallbackUrl) {
   const parsed = parseUrl(requestingUrl) ?? parseUrl(fallbackUrl);
   return parsed?.origin && parsed.origin !== "null" ? parsed.origin : "";
 }
@@ -12173,18 +11830,19 @@ function nextAvailableDownloadPath(downloadsDirectory, filename, exists) {
   return candidate;
 }
 
-// src/drivers/electron/native/session.ts
+// src/electron/session.ts
 var import_electron2 = require("electron");
-var browserSession = null;
-function getBrowserSession() {
-  if (!browserSession) browserSession = import_electron2.session.fromPartition(BROWSER_SESSION_PARTITION, { cache: true });
-  return browserSession;
+var import_node_crypto = require("node:crypto");
+function getBrowserSession(accountId) {
+  if (!accountId) throw new Error("Native browsing requires an Amalgm account.");
+  const key = (0, import_node_crypto.createHash)("sha256").update(accountId).digest("hex");
+  return import_electron2.session.fromPartition(`persist:amalgm-browser-${key}`, { cache: true });
 }
 
-// src/drivers/electron/native/surface-controller.ts
-var import_electron5 = require("electron");
+// src/electron/surface-controller.ts
+var import_electron4 = require("electron");
 
-// src/drivers/electron/native/surface/state.ts
+// src/electron/surface/state.ts
 function validSurfaceId(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 200;
 }
@@ -12194,11 +11852,12 @@ function normalizeBounds(bounds, owner) {
   const width = finiteNumber(bounds?.width);
   const height = finiteNumber(bounds?.height);
   if (x === null || y === null || width === null || height === null) return null;
+  const zoom = owner.webContents.getZoomFactor();
   const content = owner.getContentBounds();
-  const left = Math.max(0, Math.round(x));
-  const top = Math.max(0, Math.round(y));
-  const right = Math.min(content.width, Math.round(x + Math.max(0, width)));
-  const bottom = Math.min(content.height, Math.round(y + Math.max(0, height)));
+  const left = Math.max(0, Math.round(x * zoom));
+  const top = Math.max(0, Math.round(y * zoom));
+  const right = Math.min(content.width, Math.round((x + Math.max(0, width)) * zoom));
+  const bottom = Math.min(content.height, Math.round((y + Math.max(0, height)) * zoom));
   return { x: left, y: top, width: Math.max(0, right - left), height: Math.max(0, bottom - top) };
 }
 function stateFor(record) {
@@ -12238,7 +11897,7 @@ function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
-// src/drivers/electron/native/surface/commands.ts
+// src/electron/surface/commands.ts
 var MIN_ZOOM = 0.5;
 var MAX_ZOOM = 3;
 function executeSurfaceCommand(record, request, presentation, isAllowedUrl) {
@@ -12283,7 +11942,7 @@ function executeSurfaceCommand(record, request, presentation, isAllowedUrl) {
   return stateFor(record);
 }
 
-// src/drivers/electron/native/surface/create.ts
+// src/electron/surface/create.ts
 var import_electron3 = require("electron");
 function createSurfaceRecord(sender, request, options) {
   const owner = import_electron3.BrowserWindow.fromWebContents(sender);
@@ -12311,13 +11970,8 @@ function createSurfaceRecord(sender, request, options) {
     view,
     owner,
     embedder: sender,
-    isAutomation: request.isAutomation === true,
-    automationSessionId: validSurfaceId(request.automationSessionId) ? request.automationSessionId : null,
-    parkingWindow: null,
-    parent: "owner",
     bounds: { x: 0, y: 0, width: 0, height: 0 },
     requestedVisible: false,
-    displayScale: 1,
     zoomFactor: 1,
     ready: false,
     title: "",
@@ -12328,7 +11982,7 @@ function createSurfaceRecord(sender, request, options) {
   };
 }
 
-// src/drivers/electron/native/surface/events.ts
+// src/electron/surface/events.ts
 function configureSurfaceEvents(record, presentation, sendState, destroyed) {
   const contents = record.view.webContents;
   contents.on("did-start-loading", () => {
@@ -12344,7 +11998,6 @@ function configureSurfaceEvents(record, presentation, sendState, destroyed) {
   contents.on("dom-ready", () => {
     record.ready = true;
     presentation.applyZoom(record);
-    stampAutomationIdentity(record);
     presentation.apply(record);
     sendState();
   });
@@ -12358,13 +12011,11 @@ function configureSurfaceEvents(record, presentation, sendState, destroyed) {
   });
   contents.on("did-navigate", () => {
     record.loadError = null;
-    stampAutomationIdentity(record);
     sendState();
   });
   contents.on("did-navigate-in-page", (_event, _url, mainFrame) => {
     if (!mainFrame) return;
     record.loadError = null;
-    stampAutomationIdentity(record);
     sendState();
   });
   contents.on("did-fail-load", (_event, code, description, url, mainFrame) => {
@@ -12381,110 +12032,34 @@ function configureSurfaceEvents(record, presentation, sendState, destroyed) {
   });
   contents.once("destroyed", destroyed);
 }
-function stampAutomationIdentity(record) {
-  const contents = record.view.webContents;
-  if (!record.automationSessionId || contents.isDestroyed()) return;
-  void contents.executeJavaScript(
-    `window.__amalgmBsid = ${JSON.stringify(record.automationSessionId)};`
-  ).catch(() => {
-  });
-}
 
-// src/drivers/electron/native/surface/presentation.ts
-var import_electron4 = require("electron");
-var PARKED_VIEWPORT = { width: 1440, height: 900 };
-var PARKING_ORIGIN = -1e4;
+// src/electron/surface/presentation.ts
 var MAX_ZOOM2 = 3;
 var SurfacePresentation = class {
   detach(record) {
-    if (record.parent === "owner" && !record.owner.isDestroyed()) {
-      record.owner.contentView.removeChildView(record.view);
-    }
-    if (record.parent === "parking" && record.parkingWindow && !record.parkingWindow.isDestroyed()) {
-      record.parkingWindow.contentView.removeChildView(record.view);
-    }
-    record.parent = null;
+    if (!record.owner.isDestroyed()) record.owner.contentView.removeChildView(record.view);
   }
   applyZoom(record) {
     const contents = record.view.webContents;
     if (contents.isDestroyed()) return;
-    const scale = record.parent === "parking" ? 1 : record.displayScale;
-    const factor = Math.max(0.1, Math.min(MAX_ZOOM2, record.zoomFactor * scale));
+    const factor = Math.max(0.1, Math.min(MAX_ZOOM2, record.zoomFactor));
     if (Math.abs(contents.getZoomFactor() - factor) >= 1e-3) contents.setZoomFactor(factor);
   }
+  /** Shows the page in its tab's box while the tab asks and has room; hides it otherwise. */
   apply(record) {
-    const hasArea = record.bounds.width > 0 && record.bounds.height > 0;
-    if (record.requestedVisible && hasArea) this.show(record);
-    else this.hide(record);
-  }
-  destroyParking(record) {
-    if (record.parkingWindow && !record.parkingWindow.isDestroyed()) record.parkingWindow.destroy();
-    record.parkingWindow = null;
-  }
-  show(record) {
-    if (record.parent !== "owner") {
-      this.detach(record);
-      record.owner.contentView.addChildView(record.view);
-      record.parent = "owner";
-      record.parkingWindow?.hide();
-    } else {
-      record.owner.contentView.addChildView(record.view);
-    }
-    record.view.setBounds(record.bounds);
-    record.view.setVisible(true);
-    this.applyZoom(record);
-  }
-  hide(record) {
-    if (record.isAutomation) {
-      this.park(record);
+    if (!record.requestedVisible || record.bounds.width <= 0 || record.bounds.height <= 0) {
+      record.view.setVisible(false);
       return;
     }
-    if (record.parent !== "owner") {
-      this.detach(record);
-      record.owner.contentView.addChildView(record.view);
-      record.parent = "owner";
-    }
-    record.view.setVisible(false);
-  }
-  park(record) {
-    const parkingWindow = this.parkingWindow(record);
-    if (record.parent !== "parking") {
-      this.detach(record);
-      parkingWindow.contentView.addChildView(record.view);
-      record.parent = "parking";
-    }
-    record.view.setBounds({ x: 0, y: 0, ...PARKED_VIEWPORT });
+    record.owner.contentView.addChildView(record.view);
+    record.view.setBounds(record.bounds);
     record.view.setVisible(true);
     this.applyZoom(record);
-    parkingWindow.showInactive();
-  }
-  parkingWindow(record) {
-    if (record.parkingWindow && !record.parkingWindow.isDestroyed()) return record.parkingWindow;
-    record.parkingWindow = new import_electron4.BaseWindow({
-      show: false,
-      x: PARKING_ORIGIN,
-      y: PARKING_ORIGIN,
-      ...PARKED_VIEWPORT,
-      focusable: true,
-      skipTaskbar: true,
-      hiddenInMissionControl: true,
-      frame: false,
-      hasShadow: false,
-      closable: false,
-      minimizable: false,
-      maximizable: false,
-      movable: false,
-      resizable: false,
-      fullscreenable: false,
-      roundedCorners: false,
-      backgroundColor: "#ffffff"
-    });
-    return record.parkingWindow;
   }
 };
 
-// src/drivers/electron/native/surface-controller.ts
-var CAPTURE_TIMEOUT_MS = 300;
+// src/electron/surface-controller.ts
+var CAPTURE_STALL_MS = 2e3;
 function createBrowserSurfaceController(options) {
   const surfaces = /* @__PURE__ */ new Map();
   const ownerSurfaceIds = /* @__PURE__ */ new Map();
@@ -12498,7 +12073,6 @@ function createBrowserSurfaceController(options) {
     surfaces.delete(record.surfaceId);
     ownerSurfaceIds.get(record.embedder.id)?.delete(record.surfaceId);
     presentation.detach(record);
-    presentation.destroyParking(record);
     if (closeContents && !record.view.webContents.isDestroyed()) record.view.webContents.close();
   };
   const destroyOwned = (ownerId) => {
@@ -12512,7 +12086,8 @@ function createBrowserSurfaceController(options) {
     const record = surfaces.get(surfaceId);
     return record && record.embedder.id === sender.id && !record.disposed ? record : null;
   };
-  import_electron5.ipcMain.handle(BROWSER_IPC.surfaceCreate, async (event, request) => {
+  import_electron4.ipcMain.handle(BROWSER_IPC.surfaceCreate, async (event, request) => {
+    if (!options.isTrustedAppUrl(event.senderFrame?.url ?? "")) return null;
     if (!request || !validSurfaceId(request.surfaceId)) return null;
     const url = String(request.url || "about:blank");
     if (!options.isAllowedUrl(url)) return null;
@@ -12537,8 +12112,7 @@ function createBrowserSurfaceController(options) {
     options.onSurfaceCreated({
       contents: record.view.webContents,
       embedder: event.sender,
-      tabId: record.tabId,
-      isAutomation: record.isAutomation
+      tabId: record.tabId
     });
     configureSurfaceEvents(
       record,
@@ -12550,43 +12124,37 @@ function createBrowserSurfaceController(options) {
     });
     return stateFor(record);
   });
-  import_electron5.ipcMain.handle(BROWSER_IPC.surfaceUpdate, (event, request) => {
+  import_electron4.ipcMain.handle(BROWSER_IPC.surfaceUpdate, (event, request) => {
     const record = request ? ownedSurface(event.sender, request.surfaceId) : null;
     if (!record || record.owner.isDestroyed()) return false;
     const bounds = normalizeBounds(request.bounds, record.owner);
     if (!bounds) return false;
-    const isAutomation = request.isAutomation === true;
-    if (record.isAutomation !== isAutomation) {
-      record.isAutomation = isAutomation;
-      options.onAutomationChanged(record.view.webContents, isAutomation);
-    }
     record.bounds = bounds;
     record.requestedVisible = request.visible === true;
-    record.displayScale = Math.max(0.1, Math.min(1, Number(request.scale) || 1));
     presentation.apply(record);
     return true;
   });
-  import_electron5.ipcMain.handle(BROWSER_IPC.surfaceDestroy, (event, surfaceId) => {
+  import_electron4.ipcMain.handle(BROWSER_IPC.surfaceDestroy, (event, surfaceId) => {
     const record = ownedSurface(event.sender, surfaceId);
     if (!record) return false;
     destroyRecord(record, true);
     return true;
   });
-  import_electron5.ipcMain.handle(BROWSER_IPC.surfaceCommand, (event, request) => {
+  import_electron4.ipcMain.handle(BROWSER_IPC.surfaceCommand, (event, request) => {
     const record = request ? ownedSurface(event.sender, request.surfaceId) : null;
     if (!record || record.view.webContents.isDestroyed()) return null;
     const state = executeSurfaceCommand(record, request, presentation, options.isAllowedUrl);
     sendState(record);
     return state;
   });
-  import_electron5.ipcMain.handle(BROWSER_IPC.surfaceCapture, async (event, surfaceId) => {
+  import_electron4.ipcMain.handle(BROWSER_IPC.surfaceCapture, async (event, surfaceId) => {
     const record = ownedSurface(event.sender, surfaceId);
     if (!record || record.view.webContents.isDestroyed()) return null;
     try {
-      const image = await withDeadline(record.view.webContents.capturePage(), CAPTURE_TIMEOUT_MS);
+      const image = await withDeadline(record.view.webContents.capturePage(), CAPTURE_STALL_MS);
       if (image.isEmpty()) return null;
       const size = image.getSize();
-      const targetWidth = Math.min(size.width, Math.max(1, record.bounds.width || PARKED_VIEWPORT.width));
+      const targetWidth = Math.min(size.width, Math.max(1, record.bounds.width || size.width));
       const normalized = size.width > targetWidth ? image.resize({ width: targetWidth, quality: "good" }) : image;
       return `data:image/jpeg;base64,${normalized.toJPEG(78).toString("base64")}`;
     } catch {
@@ -12597,29 +12165,29 @@ function createBrowserSurfaceController(options) {
     dispose() {
       for (const record of [...surfaces.values()]) destroyRecord(record, true);
       ownerSurfaceIds.clear();
-      import_electron5.ipcMain.removeHandler(BROWSER_IPC.surfaceCreate);
-      import_electron5.ipcMain.removeHandler(BROWSER_IPC.surfaceUpdate);
-      import_electron5.ipcMain.removeHandler(BROWSER_IPC.surfaceDestroy);
-      import_electron5.ipcMain.removeHandler(BROWSER_IPC.surfaceCommand);
-      import_electron5.ipcMain.removeHandler(BROWSER_IPC.surfaceCapture);
+      import_electron4.ipcMain.removeHandler(BROWSER_IPC.surfaceCreate);
+      import_electron4.ipcMain.removeHandler(BROWSER_IPC.surfaceUpdate);
+      import_electron4.ipcMain.removeHandler(BROWSER_IPC.surfaceDestroy);
+      import_electron4.ipcMain.removeHandler(BROWSER_IPC.surfaceCommand);
+      import_electron4.ipcMain.removeHandler(BROWSER_IPC.surfaceCapture);
     }
   };
 }
 
-// src/drivers/electron/native/shell/adblock-ipc.ts
-var import_electron6 = require("electron");
+// src/electron/shell/adblock-ipc.ts
+var import_electron5 = require("electron");
 var BrowserAdBlockIpc = class {
   constructor(blocker, sites) {
     this.blocker = blocker;
     this.sites = sites;
-    import_electron6.ipcMain.handle(BROWSER_IPC.adBlockGetStatus, this.getStatus);
-    import_electron6.ipcMain.handle(BROWSER_IPC.adBlockSetEnabled, this.setEnabled);
+    import_electron5.ipcMain.handle(BROWSER_IPC.adBlockGetStatus, this.getStatus);
+    import_electron5.ipcMain.handle(BROWSER_IPC.adBlockSetEnabled, this.setEnabled);
   }
   blocker;
   sites;
   dispose() {
-    import_electron6.ipcMain.removeHandler(BROWSER_IPC.adBlockGetStatus);
-    import_electron6.ipcMain.removeHandler(BROWSER_IPC.adBlockSetEnabled);
+    import_electron5.ipcMain.removeHandler(BROWSER_IPC.adBlockGetStatus);
+    import_electron5.ipcMain.removeHandler(BROWSER_IPC.adBlockSetEnabled);
   }
   getStatus = (event, guestId) => {
     if (!Number.isInteger(guestId)) return null;
@@ -12643,11 +12211,11 @@ var BrowserAdBlockIpc = class {
   };
 };
 
-// src/drivers/electron/native/shell/context-menu.ts
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-var import_electron7 = require("electron");
+// src/electron/shell/context-menu.ts
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_electron6 = require("electron");
 
-// src/drivers/electron/native/shell/helpers.ts
+// src/electron/shell/helpers.ts
 function send(embedder, channel, payload2) {
   if (!embedder.isDestroyed()) embedder.send(channel, payload2);
 }
@@ -12666,7 +12234,7 @@ function shortcutForInput(input) {
   if (key === "=" || key === "+") return "zoom-in";
   return null;
 }
-function popupWindowOptions(cosmeticPreloadPath, browserSession2) {
+function popupWindowOptions(cosmeticPreloadPath, browserSession) {
   return {
     width: 520,
     height: 680,
@@ -12679,7 +12247,7 @@ function popupWindowOptions(cosmeticPreloadPath, browserSession2) {
       trafficLightPosition: { x: 14, y: 14 }
     } : {},
     webPreferences: {
-      session: browserSession2,
+      session: browserSession,
       nodeIntegration: false,
       contextIsolation: true,
       sandbox: true,
@@ -12690,17 +12258,17 @@ function popupWindowOptions(cosmeticPreloadPath, browserSession2) {
   };
 }
 
-// src/drivers/electron/native/shell/context-menu.ts
+// src/electron/shell/context-menu.ts
 var BrowserContextMenuController = class {
   constructor(isDev) {
     this.isDev = isDev;
-    import_electron7.ipcMain.handle(BROWSER_IPC.contextAction, this.handleAction);
+    import_electron6.ipcMain.handle(BROWSER_IPC.contextAction, this.handleAction);
   }
   isDev;
   requests = /* @__PURE__ */ new Map();
   show(site, params) {
     if (site.contents.id !== site.rootGuestId) {
-      const menu = import_electron7.Menu.buildFromTemplate([
+      const menu = import_electron6.Menu.buildFromTemplate([
         ...params.isEditable ? [
           { role: "cut" },
           { role: "copy" },
@@ -12709,18 +12277,18 @@ var BrowserContextMenuController = class {
         ] : [],
         { role: "selectAll" }
       ]);
-      const owner = import_electron7.BrowserWindow.fromWebContents(site.contents);
+      const owner = import_electron6.BrowserWindow.fromWebContents(site.contents);
       menu.popup(owner ? { window: owner } : {});
       return;
     }
-    const requestId = import_node_crypto.default.randomUUID();
+    const requestId = import_node_crypto2.default.randomUUID();
     this.requests.clear();
     this.requests.set(requestId, { site, params });
     send(site.embedder, BROWSER_IPC.contextMenu, payload(requestId, site, params));
   }
   dispose() {
     this.requests.clear();
-    import_electron7.ipcMain.removeHandler(BROWSER_IPC.contextAction);
+    import_electron6.ipcMain.removeHandler(BROWSER_IPC.contextAction);
   }
   handleAction = async (event, request) => {
     const context = request ? this.requests.get(request.requestId) : null;
@@ -12751,19 +12319,19 @@ var BrowserContextMenuController = class {
         contents.selectAll();
         break;
       case "copy-link":
-        if (params.linkURL) import_electron7.clipboard.writeText(params.linkURL);
+        if (params.linkURL) import_electron6.clipboard.writeText(params.linkURL);
         break;
       case "copy-image":
         if (params.hasImageContents) contents.copyImageAt(params.x, params.y);
         break;
       case "copy-image-address":
-        if (params.srcURL) import_electron7.clipboard.writeText(params.srcURL);
+        if (params.srcURL) import_electron6.clipboard.writeText(params.srcURL);
         break;
       case "open-link-new-tab":
         if (isAllowedWebUrl(params.linkURL)) this.openTab(site, params.linkURL);
         break;
       case "open-link-external":
-        if (isAllowedWebUrl(params.linkURL)) await import_electron7.shell.openExternal(params.linkURL);
+        if (isAllowedWebUrl(params.linkURL)) await import_electron6.shell.openExternal(params.linkURL);
         break;
       case "save-link":
         if (isAllowedWebUrl(params.linkURL)) contents.downloadURL(params.linkURL);
@@ -12818,17 +12386,17 @@ function payload(requestId, site, params) {
   };
 }
 
-// src/drivers/electron/native/shell/downloads.ts
-var import_node_crypto2 = __toESM(require("node:crypto"), 1);
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_electron8 = require("electron");
+// src/electron/shell/downloads.ts
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_electron7 = require("electron");
 var UPDATE_INTERVAL_MS = 100;
 var BrowserDownloadController = class {
-  constructor(browserSession2, sites) {
-    this.browserSession = browserSession2;
+  constructor(browserSession, sites) {
+    this.browserSession = browserSession;
     this.sites = sites;
-    browserSession2.on("will-download", this.started);
-    import_electron8.ipcMain.handle(BROWSER_IPC.downloadAction, this.handleAction);
+    browserSession.on("will-download", this.started);
+    import_electron7.ipcMain.handle(BROWSER_IPC.downloadAction, this.handleAction);
   }
   browserSession;
   sites;
@@ -12836,13 +12404,13 @@ var BrowserDownloadController = class {
   dispose() {
     this.downloads.clear();
     this.browserSession.off("will-download", this.started);
-    import_electron8.ipcMain.removeHandler(BROWSER_IPC.downloadAction);
+    import_electron7.ipcMain.removeHandler(BROWSER_IPC.downloadAction);
   }
   started = (_event, item, contents) => {
     const site = this.sites.get(contents.id);
     if (!site) return;
-    const id = import_node_crypto2.default.randomUUID();
-    const savePath = nextAvailableDownloadPath(import_electron8.app.getPath("downloads"), item.getFilename(), import_node_fs4.default.existsSync);
+    const id = import_node_crypto3.default.randomUUID();
+    const savePath = nextAvailableDownloadPath(import_electron7.app.getPath("downloads"), item.getFilename(), import_node_fs3.default.existsSync);
     item.setSavePath(savePath);
     const payload2 = {
       id,
@@ -12894,12 +12462,12 @@ var BrowserDownloadController = class {
         break;
       case "open": {
         if (record.payload.state !== "completed") return false;
-        const error2 = await import_electron8.shell.openPath(record.payload.savePath);
+        const error2 = await import_electron7.shell.openPath(record.payload.savePath);
         if (error2) throw new Error(error2);
         break;
       }
       case "show":
-        import_electron8.shell.showItemInFolder(record.payload.savePath);
+        import_electron7.shell.showItemInFolder(record.payload.savePath);
         break;
       case "remove":
         this.downloads.delete(request.id);
@@ -12918,18 +12486,18 @@ function percentComplete(item) {
   return total <= 0 ? null : Math.max(0, Math.min(100, Math.round(item.getReceivedBytes() / total * 100)));
 }
 
-// src/drivers/electron/native/shell/permissions.ts
-var import_node_crypto3 = __toESM(require("node:crypto"), 1);
-var import_electron9 = require("electron");
+// src/electron/shell/permissions.ts
+var import_node_crypto4 = __toESM(require("node:crypto"), 1);
+var import_electron8 = require("electron");
 var PERMISSION_TIMEOUT_MS = 3e4;
 var BrowserPermissionController = class {
-  constructor(browserSession2, sites, isTrustedAppUrl) {
-    this.browserSession = browserSession2;
+  constructor(browserSession, sites, isTrustedAppUrl) {
+    this.browserSession = browserSession;
     this.sites = sites;
     this.isTrustedAppUrl = isTrustedAppUrl;
-    browserSession2.setPermissionCheckHandler(this.check);
-    browserSession2.setPermissionRequestHandler(this.request);
-    import_electron9.ipcMain.on(BROWSER_IPC.permissionResponse, this.respond);
+    browserSession.setPermissionCheckHandler(this.check);
+    browserSession.setPermissionRequestHandler(this.request);
+    import_electron8.ipcMain.on(BROWSER_IPC.permissionResponse, this.respond);
   }
   browserSession;
   sites;
@@ -12944,19 +12512,19 @@ var BrowserPermissionController = class {
     this.pending.clear();
     this.browserSession.setPermissionCheckHandler(null);
     this.browserSession.setPermissionRequestHandler(null);
-    import_electron9.ipcMain.off(BROWSER_IPC.permissionResponse, this.respond);
+    import_electron8.ipcMain.off(BROWSER_IPC.permissionResponse, this.respond);
   }
   check = (contents, permission, requestingOrigin, details) => {
     const requestingUrl = details.requestingUrl || requestingOrigin;
     const site = this.findSite(contents, requestingUrl);
-    const origin = permissionOrigin2(requestingUrl, site?.contents.getURL() || "");
+    const origin = permissionOrigin(requestingUrl, site?.contents.getURL() || "");
     if (site && origin) return this.decisions.get(permissionKey(origin, permission)) === true;
     return Boolean(origin && this.isTrustedAppUrl(origin) && (!contents || this.isTrustedAppUrl(contents.getURL())));
   };
   request = (contents, permission, callback, details) => {
     const requestingUrl = details.requestingUrl || contents.getURL();
     const site = this.findSite(contents, requestingUrl);
-    const origin = permissionOrigin2(requestingUrl, site?.contents.getURL() || "");
+    const origin = permissionOrigin(requestingUrl, site?.contents.getURL() || "");
     if (!site && origin && this.isTrustedAppUrl(origin) && this.isTrustedAppUrl(contents.getURL())) {
       callback(true);
       return;
@@ -12976,7 +12544,7 @@ var BrowserPermissionController = class {
       inFlight.callbacks.push(callback);
       return;
     }
-    const requestId = import_node_crypto3.default.randomUUID();
+    const requestId = import_node_crypto4.default.randomUUID();
     const timer = setTimeout(() => this.finish(requestId, false, false), PERMISSION_TIMEOUT_MS);
     this.pending.set(requestId, {
       embedderId: site.embedder.id,
@@ -13009,9 +12577,9 @@ var BrowserPermissionController = class {
     if (!contents) return null;
     const direct = this.sites.get(contents.id);
     if (direct) return direct;
-    const origin = permissionOrigin2(requestingUrl, "");
+    const origin = permissionOrigin(requestingUrl, "");
     if (!origin) return null;
-    return [...this.sites.values()].find((site) => site.embedder.id === contents.id && permissionOrigin2(site.contents.getURL(), "") === origin) ?? null;
+    return [...this.sites.values()].find((site) => site.embedder.id === contents.id && permissionOrigin(site.contents.getURL(), "") === origin) ?? null;
   }
 };
 function mediaTypes(details) {
@@ -13023,15 +12591,14 @@ function permissionKey(origin, permission) {
 ${permission}`;
 }
 
-// src/drivers/electron/native/shell/sites.ts
-var import_electron10 = require("electron");
+// src/electron/shell/sites.ts
+var import_electron9 = require("electron");
 var BrowserSiteManager = class {
   constructor(options) {
     this.options = options;
   }
   options;
   sites = /* @__PURE__ */ new Map();
-  automationEmbedders = /* @__PURE__ */ new Map();
   get(webContentsId) {
     return this.sites.get(webContentsId);
   }
@@ -13043,19 +12610,11 @@ var BrowserSiteManager = class {
   }
   configure(site) {
     this.sites.set(site.contents.id, site);
-    try {
-      site.contents.setBackgroundThrottling(!site.isAutomation);
-    } catch {
-    }
-    if (site.isAutomation) {
-      site.isAutomation = false;
-      this.updateAutomation(site, true);
-    }
     this.configurePopups(site);
     site.contents.on("will-navigate", (event, url) => {
       if (isAllowedWebUrl(url)) return;
       event.preventDefault();
-      if (isAllowedExternalUrl(url)) void import_electron10.shell.openExternal(url);
+      if (isAllowedExternalUrl(url)) void import_electron9.shell.openExternal(url);
     });
     site.contents.on("did-navigate", () => {
       if (site.contents.id === site.rootGuestId) {
@@ -13077,25 +12636,8 @@ var BrowserSiteManager = class {
     });
     site.contents.once("destroyed", () => this.remove(site));
   }
-  updateAutomation(site, isAutomation) {
-    if (site.isAutomation === isAutomation) return;
-    site.isAutomation = isAutomation;
-    try {
-      site.contents.setBackgroundThrottling(!isAutomation);
-    } catch {
-    }
-    const current = this.automationEmbedders.get(site.embedder.id) ?? 0;
-    const next = Math.max(0, current + (isAutomation ? 1 : -1));
-    if (next > 0) this.automationEmbedders.set(site.embedder.id, next);
-    else this.automationEmbedders.delete(site.embedder.id);
-    try {
-      site.embedder.setBackgroundThrottling(next === 0);
-    } catch {
-    }
-  }
   dispose() {
     this.sites.clear();
-    this.automationEmbedders.clear();
   }
   configurePopups(site) {
     site.contents.setWindowOpenHandler((details) => {
@@ -13105,7 +12647,7 @@ var BrowserSiteManager = class {
         return { action: "deny" };
       }
       if (isAllowedExternalUrl(url)) {
-        void import_electron10.shell.openExternal(url);
+        void import_electron9.shell.openExternal(url);
         return { action: "deny" };
       }
       if (!isAllowedWebUrl(url)) return { action: "deny" };
@@ -13122,28 +12664,348 @@ var BrowserSiteManager = class {
       contents: window2.webContents,
       embedder: site.embedder,
       rootGuestId: site.rootGuestId,
-      tabId: site.tabId,
-      isAutomation: false
+      tabId: site.tabId
     }));
   }
   remove(site) {
     this.sites.delete(site.contents.id);
-    if (site.isAutomation) this.updateAutomation(site, false);
     if (site.contents.id === site.rootGuestId) this.options.adBlocker.forgetGuest(site.rootGuestId);
   }
 };
-function shellSite(contents, embedder, tabId, isAutomation) {
-  return { contents, embedder, rootGuestId: contents.id, tabId, isAutomation };
+function shellSite(contents, embedder, tabId) {
+  return { contents, embedder, rootGuestId: contents.id, tabId };
+}
+
+// node_modules/@amalgm/core/dist/transport/auth.js
+var utf8 = new TextEncoder();
+var RUNTIME_TOKEN_HEADER = "x-amalgm-runtime-token";
+var LOOPBACK_ORIGIN_HOSTNAMES = ["localhost", "127.0.0.1", "[::1]", "::1"];
+var RUNTIME_CORS_ALLOWED_HEADERS = [
+  "Content-Type",
+  "Authorization",
+  "Accept",
+  "Cache-Control",
+  "Last-Event-ID",
+  "Mcp-Session-Id",
+  "X-Amalgm-Session-Id",
+  RUNTIME_TOKEN_HEADER
+].join(", ");
+
+// node_modules/@amalgm/core/dist/transport/state/api.js
+var encoder = new TextEncoder();
+
+// node_modules/@amalgm/core/dist/transport/diagnostics.js
+var DEFAULT_DIAGNOSTIC_LOG_TAIL_BYTES = 256 * 1024;
+var MAX_DIAGNOSTIC_LOG_TAIL_BYTES = 2 * 1024 * 1024;
+
+// src/cookies/policy.ts
+var PROTECTED_HOSTS = [
+  "amalgm.ai",
+  "supabase.co",
+  "supabase.io",
+  "supabase.in",
+  ...LOOPBACK_ORIGIN_HOSTNAMES
+];
+function normalizeCookieDomain(value) {
+  return value.trim().replace(/^\./, "").toLowerCase();
+}
+function cookieHostIsProtected(value, excluded = []) {
+  const host = normalizeCookieDomain(value);
+  return [...PROTECTED_HOSTS, ...excluded.map(normalizeCookieDomain)].some((candidate) => host === candidate || host.endsWith(`.${candidate}`));
+}
+function normalizePartition(partition) {
+  if (!partition?.topLevelSite) return void 0;
+  try {
+    const url = new URL(partition.topLevelSite);
+    if (!["http:", "https:"].includes(url.protocol)) return void 0;
+    const site = url.origin;
+    return { topLevelSite: site, ...partition.hasCrossSiteAncestor === void 0 ? {} : { hasCrossSiteAncestor: partition.hasCrossSiteAncestor } };
+  } catch {
+    return void 0;
+  }
+}
+function normalizeCookie(cookie, excluded = []) {
+  const name = String(cookie.name || "").slice(0, 512);
+  const host = normalizeCookieDomain(cookie.domain || "");
+  const domain = cookie.domain?.trim().startsWith(".") ? `.${host}` : host;
+  const path6 = cookie.path?.startsWith("/") ? cookie.path : "/";
+  if (!name || !host || cookieHostIsProtected(host, excluded)) return null;
+  const partitionKey = normalizePartition(cookie.partitionKey);
+  if (cookie.partitionKey && !partitionKey) return null;
+  return {
+    name,
+    value: String(cookie.value || ""),
+    domain,
+    path: path6,
+    ...Number.isFinite(cookie.expires) ? { expires: cookie.expires } : {},
+    ...cookie.httpOnly === void 0 ? {} : { httpOnly: cookie.httpOnly },
+    ...cookie.secure === void 0 ? {} : { secure: cookie.secure },
+    ...cookie.sameSite ? { sameSite: cookie.sameSite } : {},
+    ...partitionKey ? { partitionKey } : {}
+  };
+}
+function cookieKey(cookie) {
+  const partition = normalizePartition(cookie.partitionKey);
+  return JSON.stringify([
+    cookie.domain.trim().toLowerCase(),
+    cookie.path || "/",
+    cookie.name,
+    partition?.topLevelSite || "",
+    partition?.hasCrossSiteAncestor ?? null
+  ]);
+}
+
+// src/cookies/diff.ts
+function diffCookies(before, after) {
+  const left = new Map(before.map((cookie) => [cookieKey(cookie), cookie]));
+  const right = new Map(after.map((cookie) => [cookieKey(cookie), cookie]));
+  const upserts = [...right].filter(([key, value]) => !sameCookie(value, left.get(key))).map(([, value]) => value);
+  const deletes = [...left].filter(([key]) => !right.has(key)).map(([, value]) => ({
+    name: value.name,
+    domain: value.domain,
+    path: value.path,
+    ...value.partitionKey ? { partitionKey: value.partitionKey } : {}
+  }));
+  return { upserts, deletes };
+}
+function sameCookie(left, right) {
+  return left === right || !!left && !!right && left.value === right.value && left.expires === right.expires && Boolean(left.httpOnly) === Boolean(right.httpOnly) && Boolean(left.secure) === Boolean(right.secure) && (left.sameSite || "Lax") === (right.sameSite || "Lax");
+}
+
+// src/cookies/coordinator.ts
+var BrowserCookieCoordinator = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  connections = /* @__PURE__ */ new Map();
+  unsubscribeStore;
+  register(adapter) {
+    if (this.connections.has(adapter.id)) throw new Error(`Cookie adapter ${adapter.id} is already registered.`);
+    const connection = {
+      adapter,
+      current: /* @__PURE__ */ new Map(),
+      expected: /* @__PURE__ */ new Map(),
+      pending: /* @__PURE__ */ new Map(),
+      unsubscribe: () => {
+      },
+      initialized: false,
+      dirty: false,
+      closed: false,
+      excludedHosts: this.store.excludedHosts || []
+    };
+    this.connections.set(adapter.id, connection);
+    connection.unsubscribe = adapter.subscribe((change) => {
+      if (connection.closed) return;
+      if (!change) connection.initialized = false;
+      else {
+        const cookie = this.portable(connection, change.cookie);
+        if (!cookie) return;
+        const key = cookieKey(cookie);
+        const value = change.removed ? void 0 : cookie;
+        if (value) connection.current.set(key, value);
+        else connection.current.delete(key);
+        if (connection.expected.has(key) && sameCookie(value, connection.expected.get(key))) {
+          connection.expected.delete(key);
+          return;
+        }
+        connection.pending.set(key, { cookie, removed: change.removed });
+      }
+      this.wake(connection);
+    });
+    this.unsubscribeStore ||= this.store.subscribe?.(() => {
+      for (const entry of this.connections.values()) this.wake(entry);
+    });
+  }
+  sync(adapterId) {
+    const connection = this.connections.get(adapterId);
+    if (!connection || connection.closed) return Promise.resolve();
+    connection.dirty = true;
+    return this.flush(connection);
+  }
+  unregister(adapterId) {
+    const connection = this.connections.get(adapterId);
+    if (!connection) return;
+    connection.closed = true;
+    connection.unsubscribe();
+    this.connections.delete(adapterId);
+    if (!this.connections.size) {
+      this.unsubscribeStore?.();
+      this.unsubscribeStore = void 0;
+    }
+  }
+  async close(adapterId) {
+    try {
+      await this.sync(adapterId);
+    } finally {
+      this.unregister(adapterId);
+    }
+  }
+  wake(connection) {
+    connection.dirty = true;
+    if (!connection.running) void this.flush(connection).catch(() => void 0);
+  }
+  flush(connection) {
+    if (connection.running) return connection.running;
+    connection.running = Promise.resolve().then(() => this.drain(connection)).finally(() => {
+      delete connection.running;
+      if (connection.dirty && !connection.closed) this.wake(connection);
+    });
+    return connection.running;
+  }
+  async drain(connection) {
+    while (connection.dirty && !connection.closed) {
+      connection.dirty = false;
+      if (!connection.initialized) await this.initialize(connection);
+      if (!connection.initialized || connection.closed) return;
+      const pending = connection.pending;
+      connection.pending = /* @__PURE__ */ new Map();
+      if (pending.size) {
+        try {
+          await this.store.merge({
+            sourceId: connection.adapter.id,
+            upserts: [...pending.values()].filter((change) => !change.removed).map((change) => change.cookie),
+            deletes: [...pending.values()].filter((change) => change.removed).map((change) => change.cookie)
+          });
+        } catch (error2) {
+          for (const [key, change] of pending) if (!connection.pending.has(key)) connection.pending.set(key, change);
+          throw error2;
+        }
+      }
+      const delta = await this.store.changes(connection.version);
+      if (!delta.healthy || connection.closed) return;
+      if (delta.reset) {
+        connection.initialized = false;
+        connection.dirty = true;
+        continue;
+      }
+      await this.apply(connection, delta);
+      connection.version = delta.versionToken;
+    }
+  }
+  async initialize(connection) {
+    const state = await this.store.materialize();
+    if (!state.healthy || connection.closed) return;
+    connection.excludedHosts = this.store.excludedHosts || state.excludedHosts || [];
+    const local = (await connection.adapter.read()).flatMap((cookie) => this.portable(connection, cookie) || []);
+    if (connection.closed) return;
+    const previous = connection.current;
+    connection.current = new Map(local.map((cookie) => [cookieKey(cookie), cookie]));
+    const known = /* @__PURE__ */ new Set([...state.cookies.map(cookieKey), ...state.tombstones.map(({ key }) => key)]);
+    const changes = connection.version === void 0 ? { upserts: local.filter((cookie) => !known.has(cookieKey(cookie))), deletes: [] } : diffCookies([...previous.values()], local);
+    changes.upserts = changes.upserts.filter((cookie) => !sameCookie(cookie, connection.expected.get(cookieKey(cookie))));
+    changes.deletes = changes.deletes.filter((cookie) => !connection.expected.has(cookieKey(cookie)) || connection.expected.get(cookieKey(cookie)) !== void 0);
+    connection.expected.clear();
+    if (changes.upserts.length || changes.deletes.length) await this.store.merge({ sourceId: connection.adapter.id, ...changes });
+    const changed = new Set([...changes.upserts, ...changes.deletes].map(cookieKey));
+    const target = [...state.cookies.filter((cookie) => !changed.has(cookieKey(cookie))), ...changes.upserts].flatMap((cookie) => this.portable(connection, cookie) || []);
+    await this.apply(connection, { ...diffCookies(local, target), versionToken: state.versionToken });
+    connection.version = state.versionToken;
+    connection.initialized = true;
+  }
+  async apply(connection, delta) {
+    const upserts = delta.upserts.flatMap((cookie) => this.portable(connection, cookie) || []).filter((cookie) => !sameCookie(cookie, connection.current.get(cookieKey(cookie))));
+    const deletes = delta.deletes.filter((cookie) => this.portable(connection, { ...cookie, value: "" }) && connection.current.has(cookieKey(cookie)));
+    if (!upserts.length && !deletes.length || connection.closed) return;
+    for (const cookie of upserts) connection.expected.set(cookieKey(cookie), cookie);
+    for (const cookie of deletes) connection.expected.set(cookieKey(cookie), void 0);
+    await connection.adapter.apply({ upserts, deletes, versionToken: delta.versionToken });
+    for (const cookie of upserts) if (!connection.pending.has(cookieKey(cookie))) connection.current.set(cookieKey(cookie), cookie);
+    for (const cookie of deletes) if (!connection.pending.has(cookieKey(cookie))) connection.current.delete(cookieKey(cookie));
+  }
+  portable(connection, cookie) {
+    if (cookie.partitionKey && !connection.adapter.supportsPartitionedCookies) return null;
+    return normalizeCookie(cookie, connection.excludedHosts);
+  }
+};
+
+// src/electron/cookie-adapter.ts
+var ELECTRON_COOKIE_ADAPTER_ID = "electron:account";
+var ElectronCookieAdapter = class {
+  constructor(cookies) {
+    this.cookies = cookies;
+  }
+  cookies;
+  id = ELECTRON_COOKIE_ADAPTER_ID;
+  supportsPartitionedCookies = false;
+  async read() {
+    return (await this.cookies.get({})).map(fromElectron);
+  }
+  async apply(input) {
+    input.signal?.throwIfAborted();
+    for (const cookie of input.upserts) {
+      input.signal?.throwIfAborted();
+      if (!cookie.partitionKey) await this.cookies.set(toElectron(cookie));
+    }
+    for (const cookie of input.deletes || []) {
+      input.signal?.throwIfAborted();
+      if (cookie.partitionKey) continue;
+      await this.cookies.set(toElectron({ ...cookie, value: "", secure: true, expires: 0 }));
+    }
+  }
+  subscribe(changed) {
+    const listener = (_event, cookie, cause, removed) => {
+      if (removed && cause === "overwrite") return;
+      changed({ cookie: fromElectron(cookie), removed });
+    };
+    this.cookies.on("changed", listener);
+    return () => this.cookies.off("changed", listener);
+  }
+};
+function fromElectron(cookie) {
+  return {
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.domain || "",
+    path: cookie.path || "/",
+    ...typeof cookie.expirationDate === "number" && cookie.expirationDate >= 0 ? { expires: cookie.expirationDate } : {},
+    httpOnly: Boolean(cookie.httpOnly),
+    secure: Boolean(cookie.secure),
+    sameSite: cookie.sameSite === "strict" ? "Strict" : cookie.sameSite === "no_restriction" ? "None" : "Lax"
+  };
+}
+function toElectron(cookie) {
+  const hostOnly = !cookie.domain.startsWith(".");
+  return {
+    url: cookieUrl(cookie.domain, cookie.path, Boolean(cookie.secure) || cookie.sameSite === "None"),
+    name: cookie.name,
+    value: cookie.value,
+    path: cookie.path || "/",
+    secure: Boolean(cookie.secure),
+    httpOnly: Boolean(cookie.httpOnly),
+    sameSite: cookie.sameSite === "Strict" ? "strict" : cookie.sameSite === "None" ? "no_restriction" : "lax",
+    ...!hostOnly ? { domain: cookie.domain } : {},
+    ...typeof cookie.expires === "number" ? { expirationDate: cookie.expires } : {}
+  };
+}
+function cookieUrl(domain, path6, secure) {
+  const host = domain.trim().toLowerCase().replace(/^\.+/, "");
+  const normalizedPath = String(path6 || "/").startsWith("/") ? path6 || "/" : `/${path6}`;
+  return `${secure ? "https" : "http"}://${host}${normalizedPath}`;
+}
+
+// src/electron/cookie-sync.ts
+function syncElectronCookies(cookies, store) {
+  const adapter = new ElectronCookieAdapter(cookies);
+  const coordinator = new BrowserCookieCoordinator(store);
+  coordinator.register(adapter);
+  const sync = () => coordinator.sync(adapter.id);
+  void sync().catch(() => void 0);
+  return { async close() {
+    try {
+      await coordinator.close(adapter.id);
+    } catch {
+    }
+  } };
 }
 
-// src/drivers/electron/native/shell.ts
-var AUTOMATION_MARKER = "amalgm-bsid-";
+// src/electron/shell.ts
 function createBrowserShell(options) {
   let sites;
-  const adBlockDirectory = import_node_path4.default.join(import_electron11.app.getPath("userData"), "browser", "adblock");
+  const adBlockDirectory = import_node_path3.default.join(import_electron10.app.getPath("userData"), "browser", "adblock");
   const adBlocker = new NativeAdBlocker({
-    cachePath: import_node_path4.default.join(adBlockDirectory, "engine.bin"),
-    settingsPath: import_node_path4.default.join(adBlockDirectory, "settings.json"),
+    cachePath: import_node_path3.default.join(adBlockDirectory, "engine.bin"),
+    settingsPath: import_node_path3.default.join(adBlockDirectory, "settings.json"),
     resolvePage(webContentsId) {
       const site = sites?.get(webContentsId);
       if (!site || site.contents.isDestroyed()) return null;
@@ -13162,262 +13024,167 @@ function createBrowserShell(options) {
     },
     ...options.adBlockFetch ? { fetch: options.adBlockFetch } : {}
   });
-  const browserSession2 = getBrowserSession();
+  const browserSession = getBrowserSession(options.accountId);
+  const cookieSync = options.cookieStore ? syncElectronCookies(browserSession.cookies, options.cookieStore) : null;
   const contextMenus = new BrowserContextMenuController(options.isDev);
-  sites = new BrowserSiteManager({ browserSession: browserSession2, adBlocker, contextMenus });
-  const permissions = new BrowserPermissionController(browserSession2, sites, options.isTrustedAppUrl);
-  const downloads = new BrowserDownloadController(browserSession2, sites);
+  sites = new BrowserSiteManager({ browserSession, adBlocker, contextMenus });
+  const permissions = new BrowserPermissionController(browserSession, sites, options.isTrustedAppUrl);
+  const downloads = new BrowserDownloadController(browserSession, sites);
   const adBlockIpc = new BrowserAdBlockIpc(adBlocker, sites);
-  adBlocker.install(browserSession2);
-  const surfaceController = nativeBrowserSurfacesEnabled() ? createBrowserSurfaceController({
-    browserSession: browserSession2,
+  adBlocker.install(browserSession);
+  const surfaceController = createBrowserSurfaceController({
+    browserSession,
     cosmeticPreloadPath: () => adBlocker.cosmeticPreloadPath(),
     isAllowedUrl: isAllowedWebUrl,
+    isTrustedAppUrl: options.isTrustedAppUrl,
     onSurfaceCreated(surface) {
-      sites?.configure(shellSite(
-        surface.contents,
-        surface.embedder,
-        surface.tabId,
-        surface.isAutomation
-      ));
+      sites?.configure(shellSite(surface.contents, surface.embedder, surface.tabId));
       adBlocker.publish(surface.contents.id, surface.contents.id);
-    },
-    onAutomationChanged(contents, isAutomation) {
-      const site = sites?.get(contents.id);
-      if (site) sites?.updateAutomation(site, isAutomation);
-    }
-  }) : null;
-  const registerGuest = (event, registration) => {
-    if (!registration || !Number.isInteger(registration.guestId)) return;
-    const site = sites?.get(registration.guestId);
-    if (!site || site.embedder.id !== event.sender.id) return;
-    site.tabId = String(registration.tabId || "");
-    sites?.updateAutomation(site, registration.isAutomation === true);
-    adBlocker.publish(site.contents.id, site.rootGuestId);
-  };
-  import_electron11.ipcMain.on(BROWSER_IPC.registerGuest, registerGuest);
+    }
+  });
   return {
-    hardenWebview(webPreferences, params) {
-      if (!isAllowedWebUrl(params.src || "about:blank")) return false;
-      const preload = adBlocker.cosmeticPreloadPath();
-      if (preload) webPreferences.preload = preload;
-      else delete webPreferences.preload;
-      webPreferences.partition = BROWSER_SESSION_PARTITION;
-      webPreferences.nodeIntegration = false;
-      webPreferences.nodeIntegrationInSubFrames = false;
-      webPreferences.contextIsolation = true;
-      webPreferences.sandbox = true;
-      webPreferences.webSecurity = true;
-      webPreferences.webviewTag = false;
-      webPreferences.allowRunningInsecureContent = false;
-      return true;
-    },
-    attachGuest(embedder, guest) {
-      sites?.configure(shellSite(guest, embedder, null, guest.getURL().includes(AUTOMATION_MARKER)));
-    },
-    sendShortcut(target, command) {
-      if (target && !target.isDestroyed()) send(target, BROWSER_IPC.shortcut, { guestId: null, command });
-    },
-    dispose() {
-      surfaceController?.dispose();
-      import_electron11.ipcMain.off(BROWSER_IPC.registerGuest, registerGuest);
+    async dispose() {
+      surfaceController.dispose();
       permissions.dispose();
       downloads.dispose();
       adBlockIpc.dispose();
       contextMenus.dispose();
       sites?.dispose();
       adBlocker.dispose();
+      await cookieSync?.close();
     }
   };
 }
 
-// src/interaction/typing.ts
-function setValueScript(text) {
-  return `(() => {
-    const el = document.activeElement;
-    if (!el || el === document.body) throw new Error('focus did not land on a field');
-    const text = ${JSON.stringify(String(text))};
-    if (el.isContentEditable) {
-      el.textContent = text;
-    } else {
-      const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
-        : el instanceof HTMLInputElement ? HTMLInputElement.prototype
-        : null;
-      if (!proto && !('value' in el)) {
-        throw new Error('focused element <' + el.tagName.toLowerCase() + '> is not fillable');
-      }
-      const setter = proto && Object.getOwnPropertyDescriptor(proto, 'value').set;
-      if (setter) setter.call(el, text); else el.value = text;
-    }
-    el.dispatchEvent(new InputEvent('input', { bubbles: true, data: text, inputType: 'insertReplacementText' }));
-    el.dispatchEvent(new Event('change', { bubbles: true }));
-    return true;
-  })()`;
-}
-function insertTextScript(text) {
-  return `(() => {
-    const el = document.activeElement;
-    if (!el || el === document.body || el === document.documentElement) {
-      throw new Error('focus did not land on an editable field');
-    }
-    const text = ${JSON.stringify(String(text))};
-    const inputEvent = (inputType, data = text) => new InputEvent('input', {
-      bubbles: true,
-      data,
-      inputType,
-    });
+// src/errors.ts
+var BrowserError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+  code;
+  details;
+  name = "BrowserError";
+};
 
-    if (el.isContentEditable) {
-      const selection = window.getSelection();
-      if (selection && selection.rangeCount) {
-        const range = selection.getRangeAt(0);
-        range.deleteContents();
-        const node = document.createTextNode(text);
-        range.insertNode(node);
-        range.setStartAfter(node);
-        range.setEndAfter(node);
-        selection.removeAllRanges();
-        selection.addRange(range);
-      } else {
-        el.textContent = (el.textContent || '') + text;
+// src/cookies/http-store.ts
+function createHttpCookieStore(options) {
+  const listeners = /* @__PURE__ */ new Set();
+  let watching;
+  let unsubscribeReady;
+  let version;
+  async function request(action, mutation) {
+    start();
+    const response = await options.request(`/cookies/${action}`, {
+      method: mutation ? "POST" : "GET",
+      cache: "no-store",
+      signal: AbortSignal.timeout(5e3),
+      ...mutation ? { headers: { "content-type": "application/json" }, body: JSON.stringify(mutation) } : {}
+    });
+    if (!response.ok) throw new BrowserError("PROCESS_FAILED", `Browser cookie adapter is unavailable (${response.status}).`);
+    const result = await response.json();
+    if (result.accountId !== options.accountId || !result.jar) {
+      throw new BrowserError("AUTHORIZATION_DENIED", "The Browser cookie adapter answered for another account.");
+    }
+    return result.jar;
+  }
+  function start() {
+    if (watching || !listeners.size) return;
+    const controller = watching = new AbortController();
+    let live = false;
+    void watch(controller.signal, () => {
+      live = true;
+    }).catch(() => void 0).finally(() => {
+      if (watching !== controller) return;
+      watching = void 0;
+      version = void 0;
+      if (live) start();
+    });
+  }
+  async function watch(lifetime, delivered) {
+    const response = await options.request("/cookies/changes", { method: "GET", cache: "no-store", signal: lifetime });
+    if (!response.ok || !response.body) throw new Error("Cookie notifications unavailable.");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        if (buffer.length > 16e3) throw new Error("Invalid cookie notification.");
+        let end;
+        while ((end = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, end);
+          buffer = buffer.slice(end + 1);
+          if (!line.startsWith("data:")) continue;
+          const event = JSON.parse(line.slice(5));
+          if (event.accountId !== options.accountId || typeof event.versionToken !== "string") {
+            throw new Error("Invalid cookie notification identity.");
+          }
+          version = event.versionToken;
+          delivered();
+          for (const changed of listeners) changed(version);
+        }
       }
-      el.dispatchEvent(inputEvent('insertText'));
-      return true;
+    } finally {
+      await reader.cancel().catch(() => void 0);
+    }
+  }
+  return {
+    materialize: () => request("bootstrap"),
+    changes(after) {
+      if (watching && version === after) return { upserts: [], deletes: [], versionToken: after, reset: false, healthy: true };
+      return request(`delta?after=${encodeURIComponent(after)}`);
+    },
+    merge: (mutation) => request("merge", mutation),
+    subscribe(changed) {
+      listeners.add(changed);
+      if (!unsubscribeReady) unsubscribeReady = options.subscribeReady?.(() => {
+        watching?.abort();
+        watching = void 0;
+        version = void 0;
+        start();
+      });
+      start();
+      return () => {
+        listeners.delete(changed);
+        if (!listeners.size) {
+          watching?.abort();
+          watching = void 0;
+          version = void 0;
+          unsubscribeReady?.();
+          unsubscribeReady = void 0;
+        }
+      };
     }
-
-    const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
-      : el instanceof HTMLInputElement ? HTMLInputElement.prototype
-      : null;
-    if (!proto && !('value' in el)) {
-      throw new Error('focused element <' + el.tagName.toLowerCase() + '> is not editable');
-    }
-    const value = String(el.value || '');
-    const start = typeof el.selectionStart === 'number' ? el.selectionStart : value.length;
-    const end = typeof el.selectionEnd === 'number' ? el.selectionEnd : start;
-    const next = value.slice(0, start) + text + value.slice(end);
-    const setter = proto && Object.getOwnPropertyDescriptor(proto, 'value').set;
-    if (setter) setter.call(el, next); else el.value = next;
-    const caret = start + text.length;
-    if (typeof el.setSelectionRange === 'function') {
-      try { el.setSelectionRange(caret, caret); } catch {}
-    }
-    el.dispatchEvent(inputEvent('insertText'));
-    return true;
-  })()`;
-}
-function codeFor(key) {
-  if (/^[a-z]$/i.test(key)) return `Key${key.toUpperCase()}`;
-  if (/^[0-9]$/.test(key)) return `Digit${key}`;
-  if (key === " ") return "Space";
-  return key;
-}
-function keyScript(combo) {
-  const parts = String(combo).split("+");
-  const key = parts.pop() || "";
-  const mods = parts.map((part) => part.toLowerCase());
-  const init = {
-    key,
-    code: codeFor(key),
-    bubbles: true,
-    cancelable: true,
-    ctrlKey: mods.includes("control") || mods.includes("ctrl"),
-    shiftKey: mods.includes("shift"),
-    altKey: mods.includes("alt") || mods.includes("option"),
-    metaKey: mods.includes("meta") || mods.includes("cmd") || mods.includes("command")
   };
-  return `(() => {
-    const el = document.activeElement || document.body;
-    const init = ${JSON.stringify(init)};
-    const isInput = el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement;
-    const isEditable = isInput || el.isContentEditable;
-    const inputEvent = (inputType, data = null) => new InputEvent('input', {
-      bubbles: true,
-      data,
-      inputType,
-    });
-    const setValue = (next, start, end = start) => {
-      const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
-        : el instanceof HTMLInputElement ? HTMLInputElement.prototype
-        : null;
-      const setter = proto && Object.getOwnPropertyDescriptor(proto, 'value').set;
-      if (setter) setter.call(el, next); else el.value = next;
-      if (typeof el.setSelectionRange === 'function') {
-        try { el.setSelectionRange(start, end); } catch {}
-      }
-    };
-    const proceed = el.dispatchEvent(new KeyboardEvent('keydown', init));
-    if (proceed) {
-      el.dispatchEvent(new KeyboardEvent('keypress', init));
-      if ((init.ctrlKey || init.metaKey) && init.key.toLowerCase() === 'a' && isEditable) {
-        if (isInput && typeof el.select === 'function') {
-          el.select();
-        } else {
-          const range = document.createRange();
-          range.selectNodeContents(el);
-          const selection = window.getSelection();
-          selection.removeAllRanges();
-          selection.addRange(range);
-        }
-      } else if ((init.key === 'Backspace' || init.key === 'Delete') && isInput) {
-        const value = String(el.value || '');
-        const selectionStart = typeof el.selectionStart === 'number' ? el.selectionStart : value.length;
-        const selectionEnd = typeof el.selectionEnd === 'number' ? el.selectionEnd : selectionStart;
-        let start = selectionStart;
-        let end = selectionEnd;
-        if (start === end && init.key === 'Backspace' && start > 0) start -= 1;
-        if (start === end && init.key === 'Delete' && end < value.length) end += 1;
-        if (start !== end) {
-          setValue(value.slice(0, start) + value.slice(end), start);
-          el.dispatchEvent(inputEvent(init.key === 'Backspace' ? 'deleteContentBackward' : 'deleteContentForward'));
-        }
-      } else if (init.key === 'Enter') {
-        if (el instanceof HTMLButtonElement || el instanceof HTMLAnchorElement) {
-          el.click();
-        } else if (el instanceof HTMLInputElement && el.form) {
-          if (el.form.requestSubmit) el.form.requestSubmit(); else el.form.submit();
-        }
-      }
-    }
-    el.dispatchEvent(new KeyboardEvent('keyup', init));
-    return true;
-  })()`;
+}
+
+// src/cookies/adapter-credential.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var FILE = "cookie-adapter.json";
+function readCookieAdapter(root, accountId) {
+  const file = import_node_path4.default.join(root, FILE);
+  let record;
+  try {
+    record = JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (record.version !== 1 || record.accountId !== accountId) {
+    throw new BrowserError("AUTHORIZATION_DENIED", "The Browser adapter belongs to another account.");
+  }
+  return typeof record.token === "string" && record.token.length >= 32 ? record.token : null;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BROWSER_IPC,
-  BROWSER_SESSION_PARTITION,
-  BROWSER_SURFACE_PROTOCOL,
-  BROWSER_SURFACE_PROTOCOLS,
-  ELECTRON_COOKIE_ADAPTER_ID,
-  ElectronBrowserDriver,
-  ElectronCookieAdapter,
-  NativeAdBlocker,
-  adBlockHostname,
-  browserNavigationPolicy,
-  codeFor,
   createBrowserShell,
-  createBrowserSurfaceController,
-  getBrowserSession,
-  insertTextScript,
-  isAdBlockCacheFresh,
-  isAllowedExternalUrl,
-  isAllowedWebUrl,
-  isLoopbackCdpUrl,
-  isNativeAdBlockDisabled,
-  isolatedBrowserSession,
-  keyScript,
-  markerUrl,
-  nextAvailableDownloadPath,
-  normalizeBrowserLocation,
-  parseUrl,
-  permissionOrigin,
-  removeHostAdvertisement,
-  safeDownloadFilename,
-  safeDownloadName,
-  setValueScript,
-  shouldOpenAsTab,
-  surfaceStamp,
-  writeHostAdvertisement
+  createHttpCookieStore,
+  readCookieAdapter
 });
 /*! Bundled license information: