browser-debugger-cli 0.13.0 → 0.14.0

package/dist/daemon.js

@@ -5013,9 +5013,12 @@ var OBJECT_EXPANSION_MAX_DEPTH = 3;
 var OBJECT_EXPANSION_MAX_PROPERTIES = 10;
 var OBJECT_EXPANSION_FAILURE_THRESHOLD = 5;
 var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+var MAX_TOTAL_BODY_BYTES = 100 * 1024 * 1024;
 var CHROME_NETWORK_BUFFER_TOTAL = 50 * 1024 * 1024;
 var CHROME_NETWORK_BUFFER_PER_RESOURCE = 10 * 1024 * 1024;
 var CHROME_POST_DATA_LIMIT = 1 * 1024 * 1024;
+var LAYOUT_ELEMENT_LIMIT = 100;
+var MAX_TRIGGERED_REQUESTS = 50;
 var DEFAULT_PAGE_READINESS_TIMEOUT_MS = 2e3;
 var MAX_JSONL_BUFFER_SIZE = 256 * 1024 * 1024;
 
@@ -5533,7 +5536,13 @@ function evalPreviewWarning(replaced) {
 
 // src/daemon/session/TelemetryStore.ts
 var TelemetryStore = class {
+  /**
+   * Finished requests, oldest first: the newest are kept, so the session's
+   * `networkEvictions.requestsDropped` oldest ones are gone
+   */
   networkRequests = [];
+  /** Requests dropped and response bodies evicted at the capture limits */
+  networkEvictions = { requestsDropped: 0, bodiesEvicted: 0 };
   /** Requests still in flight, keyed by CDP requestId */
   pendingNetworkRequests = /* @__PURE__ */ new Map();
   consoleMessages = [];
@@ -6747,6 +6756,9 @@ function sessionEndedDuringCommandError() {
     suggestion: `Start a new session with: ${sessionCommand("bdg <url>")}`
   };
 }
+function unknownSessionCommandMessage(name) {
+  return `Unknown session command: "${name}"`;
+}
 function navigationFailedError(url, errorText) {
   return {
     message: `Could not load ${url}: ${errorText}`,
@@ -7260,9 +7272,10 @@ async function fetchCDPTargets(port = DEFAULT_CDP_PORT, logger, options) {
 }
 async function probeDevToolsEndpoint(port, logger, options) {
   const url = `${options?.secure ? "https" : "http"}://${options?.host ?? HTTP_LOCALHOST}:${port}/json/version`;
+  const timeoutMs = options?.timeoutMs ?? CDP_HTTP_TIMEOUT_MS;
   let response;
   try {
-    response = await fetch(url, { signal: AbortSignal.timeout(CDP_HTTP_TIMEOUT_MS) });
+    response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
   } catch (error) {
     logger?.debug(`Chrome version request failed: ${getErrorMessage(error)} (${url})`);
     return { kind: "unreachable" };
@@ -8342,6 +8355,234 @@ function listProcesses() {
   return result.stdout.split("\n").map((line) => /^\s*(\d+)\s+(.*)$/.exec(line)).filter((match) => match !== null).map(([, pid, command]) => ({ pid: Number(pid), command: command ?? "" }));
 }
 
+// src/connection/diagnostics.ts
+var log4 = createLogger("diagnostics");
+var cachedDiagnostics = null;
+function getChromeDiagnostics() {
+  if (cachedDiagnostics) {
+    return cachedDiagnostics;
+  }
+  let defaultPath = null;
+  try {
+    defaultPath = getChromePath();
+  } catch (error) {
+    log4.debug(`Failed to get default Chrome path: ${getErrorMessage(error)}`);
+  }
+  let installations = [];
+  try {
+    installations = Launcher.getInstallations();
+  } catch (error) {
+    log4.debug(`Failed to get Chrome installations: ${getErrorMessage(error)}`);
+  }
+  cachedDiagnostics = {
+    defaultPath,
+    installations,
+    installationCount: installations.length
+  };
+  return cachedDiagnostics;
+}
+
+// src/ui/messages/chrome.ts
+function formatChromeNotice(notice) {
+  const ctx = notice.context ?? {};
+  switch (notice.code) {
+    case "EXTERNAL_CHROME_CONNECTING":
+      return chromeExternalConnectionMessage();
+    case "EXTERNAL_CHROME_WS_URL":
+      return chromeExternalWebSocketMessage(ctx["wsUrl"]);
+    case "EXTERNAL_CHROME_NO_PID":
+      return chromeExternalNoPidMessage();
+    case "EXTERNAL_CHROME_SKIP_TERMINATION":
+      return chromeExternalSkipTerminationMessage();
+  }
+}
+function formatChromeIssue(issue) {
+  const ctx = issue.context ?? {};
+  switch (issue.code) {
+    case "PORT_IN_USE":
+      return portInUseError(ctx["port"], ctx["reason"]);
+    case "INVALID_PORT":
+      return invalidPortError(ctx["port"]);
+    case "USER_DATA_DIR_CREATE_FAILED":
+      return userDataDirError(ctx["userDataDir"], ctx["reason"] ?? "");
+    case "CHROME_LAUNCH_FAILED":
+    case "CHROME_DIED_AFTER_LAUNCH": {
+      const port = ctx["port"];
+      const reason = ctx["reason"];
+      const pid = typeof ctx["pid"] === "number" ? ctx["pid"] : "unknown";
+      const header2 = issue.code === "CHROME_DIED_AFTER_LAUNCH" ? `Chrome died immediately after launch (PID: ${pid})` : reason ? chromeLaunchFailedError(reason) : `Chrome failed to launch`;
+      const diagnostics = getFormattedDiagnostics();
+      return joinLines(
+        header2,
+        "",
+        "Possible causes:",
+        `  - Port ${port} conflict (check: lsof -ti:${port})`,
+        `  - Chrome binary not found`,
+        `  - Insufficient permissions`,
+        `  - Chrome crashed on startup`,
+        "",
+        ...diagnostics,
+        "",
+        "Try:",
+        `  - ${sessionCommand("bdg cleanup")}`,
+        `  - See what uses the port: lsof -i :${port}`,
+        `  - Use different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`,
+        `  - In a container where Chrome's sandbox fails: BDG_NO_SANDBOX=1 ${sessionCommand("bdg <url>")}`
+      );
+    }
+    case "CHROME_EXITED_DURING_STARTUP":
+      return chromeExitedDuringStartupError(
+        ctx["exitCode"],
+        ctx["output"] ?? [],
+        ctx["userDataDir"],
+        ctx["profileInUse"] === true
+      );
+    case "NO_PAGE_TARGET_FOUND":
+      return noPageTargetFoundError(
+        ctx["port"],
+        ctx["availableTargets"]
+      );
+    case "CHROME_BINARY_NOT_FOUND": {
+      const diagnostics = getFormattedDiagnostics();
+      return joinLines(
+        chromeBinaryOverrideNotFound(ctx["chromePath"], ctx["source"]),
+        "",
+        ...diagnostics
+      );
+    }
+    case "CHROME_BINARY_IS_DIRECTORY":
+      return chromeBinaryOverrideIsDirectory(ctx["chromePath"], ctx["source"]);
+    case "CHROME_BINARY_NOT_EXECUTABLE": {
+      const reason = ctx["reason"];
+      const base = chromeBinaryOverrideNotExecutable(
+        ctx["chromePath"],
+        ctx["source"]
+      );
+      return reason ? `${base}
+
+${reason}` : base;
+    }
+    case "PREFS_FILE_NOT_FOUND":
+      return prefsFileNotFoundError(ctx["file"]);
+    case "PREFS_INVALID_FORMAT":
+      return invalidPrefsFormatError(ctx["file"], ctx["actualType"]);
+    case "PREFS_LOAD_FAILED":
+      return prefsLoadError(ctx["file"], ctx["reason"] ?? "");
+    case "PREFS_NOT_JSON_SERIALIZABLE":
+      return `Chrome preferences must be JSON-serializable: ${ctx["reason"] ?? "unknown error"}`;
+  }
+}
+function chromeExitedDuringStartupError(exitCode, output, userDataDir, profileInUse2) {
+  if (profileInUse2) {
+    return joinLines(
+      `The Chrome profile ${userDataDir} is in use by another Chrome`,
+      `Close that Chrome, or use another profile directory: ${sessionCommand("bdg <url> -u ./other-profile")}`
+    );
+  }
+  return joinLines(
+    `Chrome exited during startup (exit code ${exitCode ?? "none"})`,
+    ...output.length > 0 ? ["Chrome said:", ...output.map((line) => `  ${line}`)] : [],
+    "Check --chrome-flags and BDG_CHROME_FLAGS (an unknown flag or value can stop Chrome)"
+  );
+}
+function getFormattedDiagnostics() {
+  return formatDiagnosticsForError(getChromeDiagnostics());
+}
+function formatDiagnosticsForError(diagnostics) {
+  const lines = [];
+  if (diagnostics.installationCount === 0) {
+    lines.push("Error: No Chrome installations detected\n");
+    lines.push("Install Chrome from:");
+    lines.push("   https://www.google.com/chrome/\n");
+  } else {
+    lines.push(`Found ${pluralize(diagnostics.installationCount, "Chrome installation")}:
+`);
+    diagnostics.installations.forEach((path9, index) => {
+      lines.push(`  ${index + 1}. ${path9}`);
+    });
+    lines.push("");
+    if (diagnostics.defaultPath) {
+      lines.push(`Default binary: ${diagnostics.defaultPath}
+`);
+    } else {
+      lines.push("Default binary: Could not determine\n");
+    }
+  }
+  return lines;
+}
+function invalidPortError(port) {
+  return `Invalid port number: ${port}. Port must be between 1 and 65535.`;
+}
+function userDataDirError(dir, error) {
+  return `Failed to create user data directory at ${dir}: ${error}`;
+}
+function chromeExternalConnectionMessage() {
+  return "Connecting to existing Chrome instance...";
+}
+function chromeExternalWebSocketMessage(wsUrl) {
+  return `WebSocket URL: ${wsUrl}`;
+}
+function chromeExternalNoPidMessage() {
+  return "Using external Chrome (no PID - not managed by bdg)";
+}
+function chromeExternalSkipTerminationMessage() {
+  return "Using external Chrome - skipping termination (not managed by bdg)";
+}
+function noPageTargetFoundError(port, availableTargets) {
+  return joinLines(
+    `Chrome started but opened no page to attach to (port ${port})`,
+    `Retry: ${sessionCommand("bdg <url>")}. If it keeps failing, another program may use the port (lsof -i :${port}) or a crashed session may be left over: ${sessionCommand("bdg cleanup")} && ${sessionCommand("bdg <url>")}`,
+    ...availableTargets ? ["", `Chrome targets:
+${availableTargets}`] : []
+  );
+}
+function prefsFileNotFoundError(file) {
+  return `Chrome preferences file not found: ${file}`;
+}
+function invalidPrefsFormatError(file, type) {
+  return `Invalid Chrome preferences format in ${file}: expected object, got ${type}`;
+}
+function prefsLoadError(file, error) {
+  return `Failed to load Chrome preferences from ${file}: ${error}`;
+}
+function chromeLaunchFailedError(error) {
+  return `Failed to launch Chrome: ${error}`;
+}
+function chromeBinaryOverrideNotFound(path9, source) {
+  return `Chrome binary override (${source}) points to "${path9}", but that file does not exist.`;
+}
+function chromeBinaryOverrideNotExecutable(path9, source) {
+  return `Chrome binary override (${source}) points to "${path9}", but it is not an executable file.
+Update the path to the Chrome binary (e.g. /Applications/Google Chrome.app/Contents/MacOS/Google Chrome) or unset the override to let bdg auto-detect Chrome.`;
+}
+function chromeBinaryOverrideIsDirectory(path9, source) {
+  return `Chrome binary override (${source}) points to "${path9}", which is a directory, not an executable file.`;
+}
+function portInUseError(port, reason) {
+  return joinLines(
+    reason ? `Port ${port} is already in use: ${reason}.
+` : `Port ${port} is already in use.
+`,
+    "Another program (or a Chrome left from a previous session) is listening on it.\n",
+    "Try:",
+    `  - Use a different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`,
+    `  - If a bdg session holds it: find it with bdg sessions, then end that one: bdg stop --session <name> (bdg cleanup --force --session <name> if it is stuck)`,
+    `  - See what uses the port: lsof -i :${port}`
+  );
+}
+function portTakenByReason(answeredBy, chromeHost) {
+  if (answeredBy === "nothing")
+    return `something holds 127.0.0.1 (Chrome fell back to ${chromeHost})`;
+  const other = answeredBy === "browser" ? "another browser" : "another process";
+  return `${other} answers on 127.0.0.1 (Chrome listens on ${chromeHost})`;
+}
+function chromeNotAnsweringReason(port, waitedMs) {
+  return `Chrome announced port ${port} but did not answer on 127.0.0.1 within ${(waitedMs / 1e3).toFixed(1)}s (slow start)`;
+}
+function chromePrefsNotAppliedMessage(file, reason) {
+  return `Warning: Chrome preferences not applied to ${file} (${reason}); password manager bubbles may capture clicks`;
+}
+
 // src/connection/portReservation.ts
 import * as net2 from "net";
 var CONNECT_CHECK_MS = 500;
@@ -8362,18 +8603,18 @@ async function isPortAnswering(port) {
   const answers = await Promise.all(LOOPBACK_HOSTS.map((host) => acceptsConnections(port, host)));
   return answers.some(Boolean);
 }
-function portInUseError(port) {
+function portInUseError2(port) {
   return new ChromeLaunchError(`Port ${port} is already in use`, {
     issue: { code: "PORT_IN_USE", context: { port } }
   });
 }
 async function reservePort(port) {
-  if (await isPortAnswering(port)) throw portInUseError(port);
+  if (await isPortAnswering(port)) throw portInUseError2(port);
   return new Promise((resolve6, reject2) => {
     const server2 = net2.createServer();
     server2.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        reject2(portInUseError(port));
+        reject2(portInUseError2(port));
       } else {
         reject2(err);
       }
@@ -8453,7 +8694,8 @@ function startupExitError(exitCode, output, userDataDir) {
 var LISTENING_PATTERN = /^DevTools listening on (ws:\/\/\S+)/;
 var ENDPOINT_WAIT_MS = 1e4;
 var ENDPOINT_POLL_MS = 50;
-var log4 = createLogger("chrome");
+var MIN_ANSWER_WAIT_MS = 1e3;
+var log5 = createLogger("chrome");
 function parseDevToolsListening(lines) {
   for (const line of [...lines].reverse()) {
     const match = LISTENING_PATTERN.exec(line.trim());
@@ -8464,7 +8706,7 @@ function parseDevToolsListening(lines) {
       if (!port || !url.pathname.startsWith("/devtools/browser/")) continue;
       return { host: url.hostname, port, browserPath: url.pathname };
     } catch (error) {
-      log4.debug(`Ignoring malformed DevTools announcement: ${String(error)}`);
+      log5.debug(`Ignoring malformed DevTools announcement: ${String(error)}`);
     }
   }
   return null;
@@ -8478,31 +8720,45 @@ async function waitForDevToolsEndpoint(logs, isRunning, timeoutMs = ENDPOINT_WAI
   }
 }
 async function verifyLaunchedChrome(options) {
-  const { logs, port, pid, timeoutMs } = options;
+  const { logs, port, pid, timeoutMs = ENDPOINT_WAIT_MS } = options;
+  const started = Date.now();
   const isRunning = () => isProcessAlive(pid);
   const endpoint = await waitForDevToolsEndpoint(logs, isRunning, timeoutMs);
-  if (!endpoint && !isRunning()) {
-    throw new ChromeLaunchError(`Chrome died immediately after launch (PID: ${pid})`, {
-      issue: { code: "CHROME_DIED_AFTER_LAUNCH", context: { port, pid } }
-    });
-  }
+  if (!endpoint && !isRunning()) throw diedError(port, pid);
   if (!endpoint) return acceptUnannouncedChrome(logs, port);
   if (endpoint.port !== port) {
     throw portTakenError(port, `Chrome listens on port ${endpoint.port} instead`);
   }
-  const answering = await fetchBrowserWsUrl(port, log4);
-  if (!answering || new URL(answering).pathname !== endpoint.browserPath) {
-    throw portTakenError(
-      port,
-      `another process answers on 127.0.0.1 (Chrome listens on ${endpoint.host})`
-    );
+  const onLoopback = endpoint.host === "127.0.0.1";
+  const deadline = onLoopback ? started + timeoutMs : Date.now();
+  const answer = await waitForAnswer(port, deadline, isRunning);
+  if (answer.kind === "devtools" && new URL(answer.wsUrl).pathname === endpoint.browserPath) {
+    log5.debug(`Chrome on port ${port} is the launched one (${endpoint.browserPath})`);
+    return;
+  }
+  if (answer.kind === "unreachable" && !isRunning()) throw diedError(port, pid);
+  if (answer.kind === "unreachable" && onLoopback) {
+    throw slowStartError(port, Date.now() - started);
+  }
+  throw portTakenError(port, portTakenByReason(answerSource(answer), endpoint.host));
+}
+async function waitForAnswer(port, deadline, isRunning) {
+  for (; ; ) {
+    const remaining = Math.max(deadline - Date.now(), MIN_ANSWER_WAIT_MS);
+    const timeoutMs = Math.min(CDP_HTTP_TIMEOUT_MS, remaining);
+    const answer = await probeDevToolsEndpoint(port, void 0, { timeoutMs });
+    if (answer.kind !== "unreachable" || !isRunning() || Date.now() >= deadline) return answer;
+    await delay(ENDPOINT_POLL_MS);
   }
-  log4.debug(`Chrome on port ${port} is the launched one (${endpoint.browserPath})`);
+}
+function answerSource(answer) {
+  if (answer.kind === "devtools") return "browser";
+  return answer.kind === "not-devtools" ? "process" : "nothing";
 }
 async function acceptUnannouncedChrome(logs, port) {
   const errLog = logs.files[0]?.file ?? "chrome-err.log";
   const missing = `Chrome did not print "DevTools listening on" to ${errLog}`;
-  if (!await fetchBrowserWsUrl(port, log4)) {
+  if (!await fetchBrowserWsUrl(port, log5)) {
     throw new ChromeLaunchError(`${missing}, and no browser answers on port ${port}`, {
       issue: {
         code: "CHROME_LAUNCH_FAILED",
@@ -8513,10 +8769,21 @@ async function acceptUnannouncedChrome(logs, port) {
   if (await acceptsConnections(port, "::1")) {
     throw portTakenError(port, `${missing}, and both 127.0.0.1 and [::1] answer`);
   }
-  log4.info(
+  log5.info(
     `Warning: ${missing}; using the browser on 127.0.0.1:${port}, which was free before the launch`
   );
 }
+function diedError(port, pid) {
+  return new ChromeLaunchError(`Chrome died immediately after launch (PID: ${pid})`, {
+    issue: { code: "CHROME_DIED_AFTER_LAUNCH", context: { port, pid } }
+  });
+}
+function slowStartError(port, waitedMs) {
+  const reason = chromeNotAnsweringReason(port, waitedMs);
+  return new ChromeLaunchError(reason, {
+    issue: { code: "CHROME_LAUNCH_FAILED", context: { port, reason } }
+  });
+}
 function portTakenError(port, reason) {
   return new ChromeLaunchError(`Port ${port} is already in use: ${reason}`, {
     issue: { code: "PORT_IN_USE", context: { port, reason } }
@@ -8550,367 +8817,147 @@ function resolveChromeBinary(options) {
     const stats = fs7.statSync(chromePath);
     if (stats.isDirectory()) {
       throw new ChromeLaunchError(
-        `Chrome binary override (${sourceLabel2}) points to "${chromePath}", which is a directory.`,
-        {
-          issue: {
-            code: "CHROME_BINARY_IS_DIRECTORY",
-            context: { chromePath, source: sourceLabel2 }
-          }
-        }
-      );
-    }
-    fs7.accessSync(chromePath, fs7.constants.X_OK);
-  } catch (error) {
-    if (error instanceof ChromeLaunchError) {
-      throw error;
-    }
-    throw new ChromeLaunchError(
-      `Chrome binary override (${sourceLabel2}) points to "${chromePath}", but it is not executable.`,
-      {
-        ...error instanceof Error && { cause: error },
-        issue: {
-          code: "CHROME_BINARY_NOT_EXECUTABLE",
-          context: { chromePath, source: sourceLabel2, reason: getErrorMessage(error) }
-        }
-      }
-    );
-  }
-  return chromePath;
-}
-
-// src/connection/launcher/flagsBuilder.ts
-import * as fs8 from "fs";
-function chromeSessionMarkerFlag(sessionDir) {
-  return `--bdg-session-dir=${sessionDir}`;
-}
-var NO_SANDBOX_ENV = "BDG_NO_SANDBOX";
-function needsNoSandbox() {
-  if (process.env[NO_SANDBOX_ENV] === "1") return true;
-  if (process.platform === "linux" && process.getuid?.() === 0) return true;
-  return fs8.existsSync("/.dockerenv");
-}
-function isDocker() {
-  try {
-    if (fs8.existsSync("/.dockerenv") || fs8.existsSync("/run/.containerenv")) {
-      return true;
-    }
-    if (fs8.existsSync("/proc/self/cgroup")) {
-      const cgroup = fs8.readFileSync("/proc/self/cgroup", "utf8");
-      return cgroup.includes("docker") || cgroup.includes("containerd");
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function defaultFlags() {
-  const flags = Launcher.defaultFlags();
-  return process.platform === "linux" ? [...flags, "--disable-setuid-sandbox"] : flags;
-}
-function buildChromeFlags(options) {
-  const baseFlags = options.ignoreDefaultFlags ? [] : defaultFlags();
-  const bdgFlags = [
-    ...options.sessionDir ? [chromeSessionMarkerFlag(options.sessionDir)] : [],
-    ...BDG_CHROME_FLAGS
-  ];
-  const dockerFlags = isDocker() ? DOCKER_CHROME_FLAGS : [];
-  const sandboxFlags = needsNoSandbox() ? ["--no-sandbox"] : [];
-  const customFlags = options.chromeFlags ?? [];
-  if (options.headless) {
-    return [
-      HEADLESS_FLAG,
-      ...baseFlags,
-      ...bdgFlags,
-      ...dockerFlags,
-      ...sandboxFlags,
-      ...customFlags
-    ];
-  }
-  return [...baseFlags, ...bdgFlags, ...dockerFlags, ...sandboxFlags, ...customFlags];
-}
-
-// src/connection/launcher/preferencesLoader.ts
-import * as fs9 from "fs";
-function loadChromePrefs(options) {
-  if (options.prefsFile) {
-    const file = options.prefsFile;
-    if (!fs9.existsSync(file)) {
-      throw new ChromeLaunchError(`Chrome preferences file not found: ${file}`, {
-        issue: { code: "PREFS_FILE_NOT_FOUND", context: { file } }
-      });
-    }
-    try {
-      const prefsContent = fs9.readFileSync(file, "utf8");
-      const parsed = JSON.parse(prefsContent);
-      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new ChromeLaunchError(
-          `Invalid Chrome preferences format in ${file}: expected object, got ${typeof parsed}`,
-          {
-            issue: {
-              code: "PREFS_INVALID_FORMAT",
-              context: { file, actualType: Array.isArray(parsed) ? "array" : typeof parsed }
-            }
-          }
-        );
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof ChromeLaunchError) {
-        throw error;
-      }
-      throw new ChromeLaunchError(`Failed to load Chrome preferences from ${file}`, {
-        ...error instanceof Error && { cause: error },
-        issue: {
-          code: "PREFS_LOAD_FAILED",
-          context: { file, reason: getErrorMessage(error) }
-        }
-      });
-    }
-  }
-  return options.prefs;
-}
-function ensureJSONCompatiblePrefs(prefs) {
-  if (prefs === void 0) {
-    return void 0;
-  }
-  try {
-    JSON.stringify(prefs);
-  } catch (error) {
-    throw new ChromeLaunchError("Chrome preferences must be JSON-serializable", {
-      ...error instanceof Error && { cause: error },
-      issue: {
-        code: "PREFS_NOT_JSON_SERIALIZABLE",
-        context: { reason: getErrorMessage(error) }
-      }
-    });
-  }
-  return prefs;
-}
-
-// src/connection/launcher/profilePreferences.ts
-import * as fs10 from "fs";
-import * as os3 from "os";
-import * as path5 from "path";
-
-// src/connection/diagnostics.ts
-var log5 = createLogger("diagnostics");
-var cachedDiagnostics = null;
-function getChromeDiagnostics() {
-  if (cachedDiagnostics) {
-    return cachedDiagnostics;
-  }
-  let defaultPath = null;
-  try {
-    defaultPath = getChromePath();
-  } catch (error) {
-    log5.debug(`Failed to get default Chrome path: ${getErrorMessage(error)}`);
-  }
-  let installations = [];
-  try {
-    installations = Launcher.getInstallations();
-  } catch (error) {
-    log5.debug(`Failed to get Chrome installations: ${getErrorMessage(error)}`);
-  }
-  cachedDiagnostics = {
-    defaultPath,
-    installations,
-    installationCount: installations.length
-  };
-  return cachedDiagnostics;
-}
-
-// src/ui/messages/chrome.ts
-function formatChromeNotice(notice) {
-  const ctx = notice.context ?? {};
-  switch (notice.code) {
-    case "EXTERNAL_CHROME_CONNECTING":
-      return chromeExternalConnectionMessage();
-    case "EXTERNAL_CHROME_WS_URL":
-      return chromeExternalWebSocketMessage(ctx["wsUrl"]);
-    case "EXTERNAL_CHROME_NO_PID":
-      return chromeExternalNoPidMessage();
-    case "EXTERNAL_CHROME_SKIP_TERMINATION":
-      return chromeExternalSkipTerminationMessage();
-  }
-}
-function formatChromeIssue(issue) {
-  const ctx = issue.context ?? {};
-  switch (issue.code) {
-    case "PORT_IN_USE":
-      return portInUseError2(ctx["port"]);
-    case "INVALID_PORT":
-      return invalidPortError(ctx["port"]);
-    case "USER_DATA_DIR_CREATE_FAILED":
-      return userDataDirError(ctx["userDataDir"], ctx["reason"] ?? "");
-    case "CHROME_LAUNCH_FAILED":
-    case "CHROME_DIED_AFTER_LAUNCH": {
-      const port = ctx["port"];
-      const reason = ctx["reason"];
-      const pid = typeof ctx["pid"] === "number" ? ctx["pid"] : "unknown";
-      const header2 = issue.code === "CHROME_DIED_AFTER_LAUNCH" ? `Chrome died immediately after launch (PID: ${pid})` : reason ? chromeLaunchFailedError(reason) : `Chrome failed to launch`;
-      const diagnostics = getFormattedDiagnostics();
-      return joinLines(
-        header2,
-        "",
-        "Possible causes:",
-        `  - Port ${port} conflict (check: lsof -ti:${port})`,
-        `  - Chrome binary not found`,
-        `  - Insufficient permissions`,
-        `  - Chrome crashed on startup`,
-        "",
-        ...diagnostics,
-        "",
-        "Try:",
-        `  - ${sessionCommand("bdg cleanup")}`,
-        `  - See what uses the port: lsof -i :${port}`,
-        `  - Use different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`,
-        `  - In a container where Chrome's sandbox fails: BDG_NO_SANDBOX=1 ${sessionCommand("bdg <url>")}`
-      );
-    }
-    case "CHROME_EXITED_DURING_STARTUP":
-      return chromeExitedDuringStartupError(
-        ctx["exitCode"],
-        ctx["output"] ?? [],
-        ctx["userDataDir"],
-        ctx["profileInUse"] === true
-      );
-    case "NO_PAGE_TARGET_FOUND":
-      return noPageTargetFoundError(
-        ctx["port"],
-        ctx["availableTargets"]
-      );
-    case "CHROME_BINARY_NOT_FOUND": {
-      const diagnostics = getFormattedDiagnostics();
-      return joinLines(
-        chromeBinaryOverrideNotFound(ctx["chromePath"], ctx["source"]),
-        "",
-        ...diagnostics
-      );
-    }
-    case "CHROME_BINARY_IS_DIRECTORY":
-      return chromeBinaryOverrideIsDirectory(ctx["chromePath"], ctx["source"]);
-    case "CHROME_BINARY_NOT_EXECUTABLE": {
-      const reason = ctx["reason"];
-      const base = chromeBinaryOverrideNotExecutable(
-        ctx["chromePath"],
-        ctx["source"]
-      );
-      return reason ? `${base}
-
-${reason}` : base;
-    }
-    case "PREFS_FILE_NOT_FOUND":
-      return prefsFileNotFoundError(ctx["file"]);
-    case "PREFS_INVALID_FORMAT":
-      return invalidPrefsFormatError(ctx["file"], ctx["actualType"]);
-    case "PREFS_LOAD_FAILED":
-      return prefsLoadError(ctx["file"], ctx["reason"] ?? "");
-    case "PREFS_NOT_JSON_SERIALIZABLE":
-      return `Chrome preferences must be JSON-serializable: ${ctx["reason"] ?? "unknown error"}`;
-  }
-}
-function chromeExitedDuringStartupError(exitCode, output, userDataDir, profileInUse2) {
-  if (profileInUse2) {
-    return joinLines(
-      `The Chrome profile ${userDataDir} is in use by another Chrome`,
-      `Close that Chrome, or use another profile directory: ${sessionCommand("bdg <url> -u ./other-profile")}`
-    );
-  }
-  return joinLines(
-    `Chrome exited during startup (exit code ${exitCode ?? "none"})`,
-    ...output.length > 0 ? ["Chrome said:", ...output.map((line) => `  ${line}`)] : [],
-    "Check --chrome-flags and BDG_CHROME_FLAGS (an unknown flag or value can stop Chrome)"
-  );
-}
-function getFormattedDiagnostics() {
-  return formatDiagnosticsForError(getChromeDiagnostics());
-}
-function formatDiagnosticsForError(diagnostics) {
-  const lines = [];
-  if (diagnostics.installationCount === 0) {
-    lines.push("Error: No Chrome installations detected\n");
-    lines.push("Install Chrome from:");
-    lines.push("   https://www.google.com/chrome/\n");
-  } else {
-    lines.push(`Found ${pluralize(diagnostics.installationCount, "Chrome installation")}:
-`);
-    diagnostics.installations.forEach((path9, index) => {
-      lines.push(`  ${index + 1}. ${path9}`);
-    });
-    lines.push("");
-    if (diagnostics.defaultPath) {
-      lines.push(`Default binary: ${diagnostics.defaultPath}
-`);
-    } else {
-      lines.push("Default binary: Could not determine\n");
-    }
-  }
-  return lines;
-}
-function invalidPortError(port) {
-  return `Invalid port number: ${port}. Port must be between 1 and 65535.`;
-}
-function userDataDirError(dir, error) {
-  return `Failed to create user data directory at ${dir}: ${error}`;
-}
-function chromeExternalConnectionMessage() {
-  return "Connecting to existing Chrome instance...";
-}
-function chromeExternalWebSocketMessage(wsUrl) {
-  return `WebSocket URL: ${wsUrl}`;
-}
-function chromeExternalNoPidMessage() {
-  return "Using external Chrome (no PID - not managed by bdg)";
-}
-function chromeExternalSkipTerminationMessage() {
-  return "Using external Chrome - skipping termination (not managed by bdg)";
-}
-function noPageTargetFoundError(port, availableTargets) {
-  return joinLines(
-    `Chrome started but opened no page to attach to (port ${port})`,
-    `Retry: ${sessionCommand("bdg <url>")}. If it keeps failing, another program may use the port (lsof -i :${port}) or a crashed session may be left over: ${sessionCommand("bdg cleanup")} && ${sessionCommand("bdg <url>")}`,
-    ...availableTargets ? ["", `Chrome targets:
-${availableTargets}`] : []
-  );
-}
-function prefsFileNotFoundError(file) {
-  return `Chrome preferences file not found: ${file}`;
-}
-function invalidPrefsFormatError(file, type) {
-  return `Invalid Chrome preferences format in ${file}: expected object, got ${type}`;
+        `Chrome binary override (${sourceLabel2}) points to "${chromePath}", which is a directory.`,
+        {
+          issue: {
+            code: "CHROME_BINARY_IS_DIRECTORY",
+            context: { chromePath, source: sourceLabel2 }
+          }
+        }
+      );
+    }
+    fs7.accessSync(chromePath, fs7.constants.X_OK);
+  } catch (error) {
+    if (error instanceof ChromeLaunchError) {
+      throw error;
+    }
+    throw new ChromeLaunchError(
+      `Chrome binary override (${sourceLabel2}) points to "${chromePath}", but it is not executable.`,
+      {
+        ...error instanceof Error && { cause: error },
+        issue: {
+          code: "CHROME_BINARY_NOT_EXECUTABLE",
+          context: { chromePath, source: sourceLabel2, reason: getErrorMessage(error) }
+        }
+      }
+    );
+  }
+  return chromePath;
 }
-function prefsLoadError(file, error) {
-  return `Failed to load Chrome preferences from ${file}: ${error}`;
+
+// src/connection/launcher/flagsBuilder.ts
+import * as fs8 from "fs";
+function chromeSessionMarkerFlag(sessionDir) {
+  return `--bdg-session-dir=${sessionDir}`;
 }
-function chromeLaunchFailedError(error) {
-  return `Failed to launch Chrome: ${error}`;
+var NO_SANDBOX_ENV = "BDG_NO_SANDBOX";
+function needsNoSandbox() {
+  if (process.env[NO_SANDBOX_ENV] === "1") return true;
+  if (process.platform === "linux" && process.getuid?.() === 0) return true;
+  return fs8.existsSync("/.dockerenv");
 }
-function chromeBinaryOverrideNotFound(path9, source) {
-  return `Chrome binary override (${source}) points to "${path9}", but that file does not exist.`;
+function isDocker() {
+  try {
+    if (fs8.existsSync("/.dockerenv") || fs8.existsSync("/run/.containerenv")) {
+      return true;
+    }
+    if (fs8.existsSync("/proc/self/cgroup")) {
+      const cgroup = fs8.readFileSync("/proc/self/cgroup", "utf8");
+      return cgroup.includes("docker") || cgroup.includes("containerd");
+    }
+    return false;
+  } catch {
+    return false;
+  }
 }
-function chromeBinaryOverrideNotExecutable(path9, source) {
-  return `Chrome binary override (${source}) points to "${path9}", but it is not an executable file.
-Update the path to the Chrome binary (e.g. /Applications/Google Chrome.app/Contents/MacOS/Google Chrome) or unset the override to let bdg auto-detect Chrome.`;
+function defaultFlags() {
+  const flags = Launcher.defaultFlags();
+  return process.platform === "linux" ? [...flags, "--disable-setuid-sandbox"] : flags;
 }
-function chromeBinaryOverrideIsDirectory(path9, source) {
-  return `Chrome binary override (${source}) points to "${path9}", which is a directory, not an executable file.`;
+function buildChromeFlags(options) {
+  const baseFlags = options.ignoreDefaultFlags ? [] : defaultFlags();
+  const bdgFlags = [
+    ...options.sessionDir ? [chromeSessionMarkerFlag(options.sessionDir)] : [],
+    ...BDG_CHROME_FLAGS
+  ];
+  const dockerFlags = isDocker() ? DOCKER_CHROME_FLAGS : [];
+  const sandboxFlags = needsNoSandbox() ? ["--no-sandbox"] : [];
+  const customFlags = options.chromeFlags ?? [];
+  if (options.headless) {
+    return [
+      HEADLESS_FLAG,
+      ...baseFlags,
+      ...bdgFlags,
+      ...dockerFlags,
+      ...sandboxFlags,
+      ...customFlags
+    ];
+  }
+  return [...baseFlags, ...bdgFlags, ...dockerFlags, ...sandboxFlags, ...customFlags];
 }
-function portInUseError2(port) {
-  return joinLines(
-    `Port ${port} is already in use.
-`,
-    "Another program (or a Chrome left from a previous session) is listening on it.\n",
-    "Try:",
-    `  - Use a different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`,
-    `  - If a bdg session holds it: find it with bdg sessions, then end that one: bdg stop --session <name> (bdg cleanup --force --session <name> if it is stuck)`,
-    `  - See what uses the port: lsof -i :${port}`
-  );
+
+// src/connection/launcher/preferencesLoader.ts
+import * as fs9 from "fs";
+function loadChromePrefs(options) {
+  if (options.prefsFile) {
+    const file = options.prefsFile;
+    if (!fs9.existsSync(file)) {
+      throw new ChromeLaunchError(`Chrome preferences file not found: ${file}`, {
+        issue: { code: "PREFS_FILE_NOT_FOUND", context: { file } }
+      });
+    }
+    try {
+      const prefsContent = fs9.readFileSync(file, "utf8");
+      const parsed = JSON.parse(prefsContent);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new ChromeLaunchError(
+          `Invalid Chrome preferences format in ${file}: expected object, got ${typeof parsed}`,
+          {
+            issue: {
+              code: "PREFS_INVALID_FORMAT",
+              context: { file, actualType: Array.isArray(parsed) ? "array" : typeof parsed }
+            }
+          }
+        );
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof ChromeLaunchError) {
+        throw error;
+      }
+      throw new ChromeLaunchError(`Failed to load Chrome preferences from ${file}`, {
+        ...error instanceof Error && { cause: error },
+        issue: {
+          code: "PREFS_LOAD_FAILED",
+          context: { file, reason: getErrorMessage(error) }
+        }
+      });
+    }
+  }
+  return options.prefs;
 }
-function chromePrefsNotAppliedMessage(file, reason) {
-  return `Warning: Chrome preferences not applied to ${file} (${reason}); password manager bubbles may capture clicks`;
+function ensureJSONCompatiblePrefs(prefs) {
+  if (prefs === void 0) {
+    return void 0;
+  }
+  try {
+    JSON.stringify(prefs);
+  } catch (error) {
+    throw new ChromeLaunchError("Chrome preferences must be JSON-serializable", {
+      ...error instanceof Error && { cause: error },
+      issue: {
+        code: "PREFS_NOT_JSON_SERIALIZABLE",
+        context: { reason: getErrorMessage(error) }
+      }
+    });
+  }
+  return prefs;
 }
 
 // src/connection/launcher/profilePreferences.ts
+import * as fs10 from "fs";
+import * as os3 from "os";
+import * as path5 from "path";
 function isPrefsObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10941,6 +10988,101 @@ var ExtraInfoTracker = class {
   }
 };
 
+// src/ui/messages/networkMessages.ts
+function megabytes(bytes) {
+  return `${Math.round(bytes / (1024 * 1024))} MB`;
+}
+function bodyEvictedReason(budgetBytes) {
+  return `evicted: total body budget (bdg keeps the newest ${megabytes(budgetBytes)} of response bodies)`;
+}
+
+// src/telemetry/networkRetention.ts
+var RequestRetention = class {
+  /**
+   * @param requests - Finished requests, oldest first (updated in place)
+   * @param limits - Request cap and body budget
+   * @param evictions - Counters updated on each drop and eviction
+   */
+  constructor(requests, limits, evictions) {
+    this.requests = requests;
+    this.limits = limits;
+    this.evictions = evictions;
+  }
+  requests;
+  limits;
+  evictions;
+  bodySizes = /* @__PURE__ */ new Map();
+  storedBodyBytes = 0;
+  /**
+   * Add a finished request, dropping the oldest one past the cap.
+   *
+   * @param request - Finished request
+   * @returns The dropped request, if one was
+   */
+  add(request) {
+    this.requests.push(request);
+    if (this.requests.length <= this.limits.maxRequests) return void 0;
+    const dropped = this.requests.shift();
+    if (!dropped) return void 0;
+    this.evictions.requestsDropped++;
+    this.forgetBody(dropped);
+    return dropped;
+  }
+  /**
+   * Store a fetched response body on a kept request, then evict the oldest
+   * bodies until the total fits the budget (a body larger than the whole
+   * budget is evicted itself). Storing a body again replaces the earlier one.
+   *
+   * @param request - Request the body belongs to
+   * @param body - Body as Chrome returned it
+   * @param base64Encoded - Whether `body` is base64
+   */
+  storeBody(request, body, base64Encoded) {
+    this.forgetBody(request);
+    request.responseBody = body;
+    if (base64Encoded) request.responseBodyBase64 = true;
+    if (body) {
+      request.decodedBodyLength = Buffer.byteLength(body, base64Encoded ? "base64" : "utf-8");
+    }
+    const size = Buffer.byteLength(body);
+    this.bodySizes.set(request, size);
+    this.storedBodyBytes += size;
+    this.enforceBodyBudget();
+  }
+  /** Evict the oldest stored bodies while their total is over the budget. */
+  enforceBodyBudget() {
+    while (this.storedBodyBytes > this.limits.maxTotalBodyBytes) {
+      const oldest = this.bodySizes.keys().next();
+      if (oldest.done) return;
+      const request = oldest.value;
+      this.forgetBody(request);
+      request.responseBody = skippedBodyPlaceholder(
+        bodyEvictedReason(this.limits.maxTotalBodyBytes)
+      );
+      delete request.responseBodyBase64;
+      this.evictions.bodiesEvicted++;
+    }
+  }
+  /**
+   * Stop counting a request's stored body.
+   *
+   * @param request - Request whose body is let go
+   */
+  forgetBody(request) {
+    const size = this.bodySizes.get(request);
+    if (size === void 0) return;
+    this.bodySizes.delete(request);
+    this.storedBodyBytes -= size;
+  }
+};
+var SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
+function skippedBodyPlaceholder(reason) {
+  return `[SKIPPED: ${reason}]`;
+}
+function skippedBodyReason(body) {
+  return body === void 0 ? void 0 : SKIPPED_BODY_PATTERN.exec(body)?.[1];
+}
+
 // src/telemetry/network.ts
 var log16 = createLogger("network");
 function shouldFilterRequest(url, includeAll, networkInclude, networkExclude) {
@@ -10952,19 +11094,12 @@ function shouldFilterRequest(url, includeAll, networkInclude, networkExclude) {
   }
   return false;
 }
-function fetchResponseBody(cdp, requestId, request, pendingFetches, sessionId) {
+function fetchResponseBody(cdp, requestId, request, pendingFetches, retention, sessionId) {
   pendingFetches.add(requestId);
   void cdp.send("Network.getResponseBody", { requestId }, sessionId).then((response) => {
     if (!pendingFetches.has(requestId)) return;
-    const typedResponse = response;
-    request.responseBody = typedResponse.body;
-    if (typedResponse.base64Encoded) request.responseBodyBase64 = true;
-    if (typedResponse.body) {
-      request.decodedBodyLength = Buffer.byteLength(
-        typedResponse.body,
-        typedResponse.base64Encoded ? "base64" : "utf-8"
-      );
-    }
+    const { body, base64Encoded } = response;
+    retention.storeBody(request, body, base64Encoded);
   }).catch((error) => {
     log16.debug(
       `Failed to fetch response body for request ${requestId}: ${getErrorMessage(error)}`
@@ -10993,13 +11128,6 @@ function createNetworkRequest(params, getCurrentNavigationId) {
     ...params.type !== void 0 && { resourceType: params.type }
   };
 }
-var SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
-function skippedBodyPlaceholder(reason) {
-  return `[SKIPPED: ${reason}]`;
-}
-function skippedBodyReason(body) {
-  return body === void 0 ? void 0 : SKIPPED_BODY_PATTERN.exec(body)?.[1];
-}
 function applyResponse(request, response, resourceType) {
   const { status, mimeType, headers, timing, remoteIPAddress, remotePort, connectionId } = response;
   request.status = status;
@@ -11090,6 +11218,9 @@ async function startNetworkCollection(cdp, requests, options = {}) {
     networkInclude = [],
     networkExclude = [],
     maxBodySize = MAX_RESPONSE_SIZE,
+    maxRequests = MAX_NETWORK_REQUESTS,
+    maxTotalBodyBytes = MAX_TOTAL_BODY_BYTES,
+    evictions = { requestsDropped: 0, bodiesEvicted: 0 },
     getCurrentNavigationId
   } = options;
   const requestMap = options.pendingRequests ?? /* @__PURE__ */ new Map();
@@ -11098,6 +11229,11 @@ async function startNetworkCollection(cdp, requests, options = {}) {
   const extraInfo = new ExtraInfoTracker((requestId) => requestMap.get(requestId)?.request);
   const registry = new CDPHandlerRegistry();
   const typed = new TypedCDPConnection(cdp);
+  const retention = new RequestRetention(requests, { maxRequests, maxTotalBodyBytes }, evictions);
+  const record = (request) => {
+    const dropped = retention.add(request);
+    if (dropped) pendingFetches.delete(dropped.requestId);
+  };
   let bodiesFetched = 0;
   let bodiesSkipped = 0;
   try {
@@ -11114,11 +11250,9 @@ async function startNetworkCollection(cdp, requests, options = {}) {
   const failRequest = (requestId, failure) => {
     const entry = requestMap.get(requestId);
     if (!entry) return;
-    if (requests.length < MAX_NETWORK_REQUESTS) {
-      applyFailure(entry.request, failure);
-      requests.push(entry.request);
-      extraInfo.complete(requestId, entry.request);
-    }
+    applyFailure(entry.request, failure);
+    record(entry.request);
+    extraInfo.complete(requestId, entry.request);
     requestMap.delete(requestId);
     redirectHops.delete(requestId);
   };
@@ -11153,17 +11287,11 @@ async function startNetworkCollection(cdp, requests, options = {}) {
       const hop = completeRedirectHop(previous.request, params, redirectHops);
       extraInfo.applyResponse(params.requestId, hop);
       extraInfo.recordRedirectHop(params.requestId, hop);
-      if (requests.length < MAX_NETWORK_REQUESTS) requests.push(hop);
+      record(hop);
     }
     if (shouldFilterRequest(params.request.url, includeAll, networkInclude, networkExclude)) {
       return;
     }
-    if (requestMap.size >= MAX_NETWORK_REQUESTS) {
-      log16.debug(
-        `Warning: Network request limit reached (${MAX_NETWORK_REQUESTS}), dropping new requests`
-      );
-      return;
-    }
     const request = createNetworkRequest(params, getCurrentNavigationId);
     extraInfo.applyRequest(params.requestId, request);
     if (params.type === "Document" && params.loaderId) {
@@ -11200,12 +11328,6 @@ async function startNetworkCollection(cdp, requests, options = {}) {
   registry.registerTyped(typed, "Network.loadingFinished", (params) => {
     const entry = requestMap.get(params.requestId);
     if (!entry) return;
-    if (requests.length >= MAX_NETWORK_REQUESTS) {
-      log16.debug(`Warning: Network request limit reached (${MAX_NETWORK_REQUESTS})`);
-      requestMap.delete(params.requestId);
-      redirectHops.delete(params.requestId);
-      return;
-    }
     const request = entry.request;
     if (params.encodedDataLength !== void 0) {
       request.encodedDataLength = params.encodedDataLength;
@@ -11225,12 +11347,12 @@ async function startNetworkCollection(cdp, requests, options = {}) {
     );
     if (decision.should) {
       bodiesFetched++;
-      fetchResponseBody(cdp, params.requestId, request, pendingFetches, entry.sessionId);
+      fetchResponseBody(cdp, params.requestId, request, pendingFetches, retention, entry.sessionId);
     } else {
       bodiesSkipped++;
       request.responseBody = skippedBodyPlaceholder(decision.reason ?? "not captured");
     }
-    requests.push(request);
+    record(request);
     extraInfo.complete(params.requestId, request);
     requestMap.delete(params.requestId);
     redirectHops.delete(params.requestId);
@@ -11482,6 +11604,7 @@ function createDefaultTelemetryPlugins() {
           fetchAllBodies: config.includeAll ?? false,
           getCurrentNavigationId: store.getCurrentNavigationId ?? void 0,
           pendingRequests: store.pendingNetworkRequests,
+          evictions: store.networkEvictions,
           ...filterDefined({
             maxBodySize: config.maxBodySize
           })
@@ -11668,7 +11791,7 @@ var COMPOSED_JS = `(node) => {
   while (walker.nextNode()) if (composes(walker.currentNode)) return true;
   return false;
 }`;
-var FLAT_TEXT_JS = `(el, limit) => {
+var FLAT_TEXT_JS = `(el, limit, fields) => {
   const composed = ${COMPOSED_JS};
   const view = el.ownerDocument.defaultView;
   let text = '';
@@ -11678,7 +11801,8 @@ var FLAT_TEXT_JS = `(el, limit) => {
     if (text.length >= limit) return;
     if (node.nodeType === 3 && visible) text += node.data.replace(/\\s+/g, ' ');
     if (node.nodeType !== 1) return;
-    if (/^(input|textarea|select)$/.test(node.localName) || node.isContentEditable) return;
+    if (/^(input|textarea)$/.test(node.localName)) return;
+    if (!fields && (node.localName === 'select' || node.isContentEditable)) return;
     const style = view.getComputedStyle(node);
     if (node.checkVisibility && !node.checkVisibility() && style.display !== 'contents') return;
     if (node.localName === 'br') text += '\\n';
@@ -13090,14 +13214,15 @@ var BIND_MATCH_FUNCTION = `function (selector, i) {
 }`;
 var log22 = createLogger("dom");
 var FILTER_MATCHING_JS = `(shadowRoots) => {
+  const composed = ${COMPOSED_JS};
+  const flatText = ${FLAT_TEXT_JS};
   const skipped = /^(script|style|noscript|template)$/;
   const hiddenText = (el) => {
-    const walker = el.ownerDocument.createTreeWalker(el, 5, {
-      acceptNode: (node) => (node.nodeType === 1 && skipped.test(node.localName) ? 2 : 1)
-    });
+    const nodes = el.localName === 'slot' ? el.assignedNodes({ flatten: true }) : (el.shadowRoot || el).childNodes;
     let text = '';
-    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    for (const node of nodes) {
       if (node.nodeType === 3) text += node.data;
+      else if (node.nodeType === 1 && !skipped.test(node.localName)) text += hiddenText(node);
     }
     return text;
   };
@@ -13105,7 +13230,8 @@ var FILTER_MATCHING_JS = `(shadowRoots) => {
     if (el.localName === 'input' && /^(submit|button|reset)$/i.test(el.type)) return el.value;
     const rendered = typeof el.innerText === 'string' &&
       (typeof el.checkVisibility !== 'function' || el.checkVisibility({ visibilityProperty: true }));
-    return (rendered ? el.innerText : hiddenText(el)).replace(/\\s+/g, ' ').trim();
+    const text = !rendered ? hiddenText(el) : composed(el) ? flatText(el, Infinity, true) : el.innerText;
+    return text.replace(/\\s+/g, ' ').trim();
   };
   const passes = (el, filter) => {
     if (filter.kind === 'visible') {
@@ -13455,15 +13581,15 @@ var BODY_ABORTED = "net::ERR_ABORTED";
 
 // src/daemon/session/triggeredRequests.ts
 var LOCAL_URL_PATTERN = /^(data|blob):/i;
-var MAX_TRIGGERED_REQUESTS = 50;
 function watchTriggeredRequests(store) {
   if (!store.activeTelemetry.includes("network")) return () => void 0;
   const startedAt = Date.now();
-  const firstFinished = store.networkRequests.length;
+  const firstFinished = requestsFinished(store);
   const firstWebSocket = store.websocketConnections.length;
   return () => {
+    const firstKept = Math.max(0, firstFinished - store.networkEvictions.requestsDropped);
     const started = [
-      ...store.networkRequests.slice(firstFinished).map((request) => ({ request })),
+      ...store.networkRequests.slice(firstKept).map((request) => ({ request })),
       ...[...store.pendingNetworkRequests.values()].map((pending) => ({
         request: pending.request,
         inFlight: true
@@ -13479,6 +13605,9 @@ function watchTriggeredRequests(store) {
     };
   };
 }
+function requestsFinished(store) {
+  return store.networkEvictions.requestsDropped + store.networkRequests.length;
+}
 function keepNotableFirst(requests, limit) {
   if (requests.length <= limit) return requests;
   const notable = requests.filter(isNotableRequest).slice(0, limit);
@@ -16041,12 +16170,113 @@ function trackStyleSheets(cdp) {
 function styleSheetHeaders(cdp) {
   return headersByConnection.get(cdp)?.values() ?? [];
 }
-async function matchedStyles(cdp, nodeId, budgetMs) {
-  const request = cdp.send("CSS.getMatchedStylesForNode", { nodeId }).then((response) => response).catch((error) => {
-    log24.debug(`CSS.getMatchedStylesForNode failed: ${String(error)}`);
-    return "failed";
+var HINTS_BUDGET_MS = 1e3;
+var RULES_BUDGET_MS = 5e3;
+var KEEP_ANSWERS_SLOWER_THAN_MS = 300;
+var KEPT_ANSWER_TTL_MS = 5e3;
+var MAX_KEPT_ANSWERS = 4;
+var STYLESHEET_EVENTS = ["CSS.styleSheetAdded", "CSS.styleSheetChanged", "CSS.styleSheetRemoved"];
+var STYLE_CHANGE_EVENTS = [
+  "CSS.mediaQueryResultChanged",
+  "DOM.attributeModified",
+  "DOM.attributeRemoved",
+  "DOM.inlineStyleInvalidated",
+  "DOM.childNodeInserted",
+  "DOM.childNodeRemoved",
+  "DOM.childNodeCountUpdated",
+  "DOM.pseudoElementAdded",
+  "DOM.pseudoElementRemoved"
+];
+var documentStylesByConnection = /* @__PURE__ */ new WeakMap();
+function documentStyles(cdp) {
+  const existing = documentStylesByConnection.get(cdp);
+  if (existing) return existing;
+  const state = { requests: /* @__PURE__ */ new Map(), slow: false, document: 0 };
+  documentStylesByConnection.set(cdp, state);
+  cdp.on("DOM.documentUpdated", (_params, sessionId) => {
+    if (sessionId) return;
+    state.document++;
+    state.requests.clear();
+    state.running = void 0;
+    state.slow = false;
+  });
+  for (const event of STYLESHEET_EVENTS) {
+    cdp.on(event, (_params, sessionId) => {
+      if (sessionId) return;
+      state.requests.clear();
+      state.slow = false;
+    });
+  }
+  for (const event of STYLE_CHANGE_EVENTS) {
+    cdp.on(event, (_params, sessionId) => {
+      if (!sessionId) state.requests.clear();
+    });
+  }
+  return state;
+}
+function resetMatchedStyles(cdp) {
+  documentStylesByConnection.get(cdp)?.requests.clear();
+}
+function settleRequest(state, nodeId, request, tookMs) {
+  if (state.running === request.promise) state.running = void 0;
+  if (request.document !== state.document) return;
+  const answered = request.answer !== "failed";
+  if (answered && tookMs <= HINTS_BUDGET_MS) state.slow = false;
+  if (answered && tookMs > KEEP_ANSWERS_SLOWER_THAN_MS) {
+    request.expiresAt = Date.now() + KEPT_ANSWER_TTL_MS;
+  } else if (state.requests.get(nodeId) === request) {
+    state.requests.delete(nodeId);
+  }
+}
+function sendMatchedRequest(cdp, state, nodeId) {
+  const sentAt = Date.now();
+  const request = {
+    document: state.document,
+    promise: cdp.send("CSS.getMatchedStylesForNode", { nodeId }).then((response) => response).catch((error) => {
+      log24.debug(`CSS.getMatchedStylesForNode failed: ${String(error)}`);
+      return "failed";
+    })
+  };
+  state.running = request.promise;
+  void request.promise.then((answer) => {
+    request.answer = answer;
+    settleRequest(state, nodeId, request, Date.now() - sentAt);
   });
-  return await raceTimeout(request, budgetMs) ?? "timeout";
+  state.requests.set(nodeId, request);
+  for (const oldest of state.requests.keys()) {
+    if (state.requests.size <= MAX_KEPT_ANSWERS) break;
+    state.requests.delete(oldest);
+  }
+  return request;
+}
+function keptRequest(state, nodeId) {
+  const kept = state.requests.get(nodeId);
+  if (!kept) return void 0;
+  state.requests.delete(nodeId);
+  if (kept.expiresAt !== void 0 && kept.expiresAt <= Date.now()) return void 0;
+  state.requests.set(nodeId, kept);
+  return kept;
+}
+async function requestWhenFree(cdp, state, nodeId, deadline) {
+  while (state.running) {
+    const kept = state.requests.get(nodeId);
+    if (kept) return kept;
+    if (await raceTimeout(state.running, deadline - Date.now()) === void 0) return void 0;
+  }
+  return state.requests.get(nodeId) ?? sendMatchedRequest(cdp, state, nodeId);
+}
+async function matchedStyles(cdp, nodeId, budgetMs, options = {}) {
+  const state = documentStyles(cdp);
+  const kept = keptRequest(state, nodeId);
+  if (kept?.answer) return kept.answer;
+  if (options.skipWhenSlow && state.slow) return "skipped";
+  const deadline = Date.now() + budgetMs;
+  const request = kept ?? await requestWhenFree(cdp, state, nodeId, deadline);
+  if (!request) return "timeout";
+  const answer = await raceTimeout(request.promise, deadline - Date.now());
+  if (answer) return answer;
+  if (request.document === state.document) state.slow = true;
+  return "timeout";
 }
 function fileName(url) {
   const path9 = url.split(/[?#]/)[0] ?? url;
@@ -16635,7 +16865,7 @@ var HOLDS_FIXED_JS = `(style) =>
   /transform|filter|perspective/.test(style.willChange) || /paint|layout|strict|content/.test(style.contain)`;
 var FIXED_TO_VIEWPORT_JS = `(n) => {
   const holdsFixed = ${HOLDS_FIXED_JS};
-  const parentOf = (node) => node.parentElement || (node.parentNode && node.parentNode.host) || null;
+  const parentOf = ${FLAT_PARENT_JS};
   for (let p = parentOf(n); p && p !== n.ownerDocument.documentElement; p = parentOf(p)) {
     if (holdsFixed(p.ownerDocument.defaultView.getComputedStyle(p))) return false;
   }
@@ -16648,7 +16878,7 @@ var ANCESTOR_CLIP_JS = `(node, rect, describe) => {
   const fixedToViewport = ${FIXED_TO_VIEWPORT_JS};
   const reasons = ${JSON.stringify(LAYOUT_REASONS)};
   const styleOf = (n) => n.ownerDocument.defaultView.getComputedStyle(n);
-  const parentOf = (n) => n.parentElement || (n.parentNode && n.parentNode.host) || null;
+  const parentOf = ${FLAT_PARENT_JS};
   const doc = node.ownerDocument;
   const rootStyle = styleOf(doc.documentElement);
   const bodyClips = rootStyle.overflowX !== 'visible' || rootStyle.overflowY !== 'visible';
@@ -16995,7 +17225,6 @@ function placeInOwnerFrame(raw, owner, mapping) {
 
 // src/runtime/dom/layout.ts
 var log26 = createLogger("dom");
-var LAYOUT_ELEMENT_LIMIT = 100;
 var CLEAR_OF_SCROLLBAR_JS = `(start, end, edge, overlay) =>
   overlay && end > edge - 16 && edge - 16 > start ? edge - 16 : end`;
 var VIEWPORT_OVERLAY_JS = `(view, viewport) => {
@@ -17235,8 +17464,6 @@ function elementLayout(raw, page) {
 // src/runtime/dom/inspect.ts
 var log27 = createLogger("dom");
 var stylesEnabled = /* @__PURE__ */ new WeakSet();
-var HINTS_BUDGET_MS = 1e3;
-var RULES_BUDGET_MS = 5e3;
 var groupCounter2 = 0;
 var PICK_MATCH_JS = `function (i) {
   if (i !== null) return i;
@@ -17412,14 +17639,16 @@ async function callOn(cdp, objectId, functionDeclaration, args) {
 }
 async function readSources(cdp, objectId, params, objectGroup) {
   const related = await relatedNodes(cdp, objectId, objectGroup);
-  const [raw, measured, styles] = await Promise.all([
+  const [raw, measured, { nodeId, ...styles }] = await Promise.all([
     readPage2(cdp, objectId, params),
     measure(cdp, params.selector, related.node),
-    readStyles(cdp, related, params)
+    readStyles(cdp, related)
   ]);
+  const matched = await readMatched(cdp, nodeId, params);
   return {
     raw,
     ...styles,
+    ...matched && { matched },
     fonts: raw.textHolder ? styles.fonts.textHolder : styles.fonts.node,
     ...measured,
     ...params.rules && { rules: true },
@@ -17500,24 +17729,25 @@ async function nodeIdLookup(cdp, related) {
   );
   return (backendNodeId) => backendNodeId === void 0 ? void 0 : ids.get(backendNodeId);
 }
-async function readStyles(cdp, related, params) {
+async function readStyles(cdp, related) {
   await enableStyleDomains(cdp);
   const nodeIdOf = await nodeIdLookup(cdp, related);
   const optionalStyle = (backendNodeId) => backendNodeId === void 0 ? Promise.resolve(void 0) : computedStyle(cdp, nodeIdOf(backendNodeId));
-  const [matched, style, parentStyle, holderStyle, nodeFonts, holderFonts, size, pseudo] = await Promise.all([
-    readMatched(cdp, nodeIdOf(related.node), params),
-    computedStyle(cdp, nodeIdOf(related.node)),
-    optionalStyle(related.parent),
-    optionalStyle(related.textHolder),
-    platformFonts(cdp, nodeIdOf(related.node)),
-    platformFonts(cdp, nodeIdOf(related.fontHolder)),
-    borderBoxSize(cdp, related.node),
-    Promise.all(
-      related.pseudo.map(
-        (p) => pseudoSource(cdp, p.type, p.backendNodeId, nodeIdOf(p.backendNodeId))
+  const [style, parentStyle, holderStyle, nodeFonts, holderFonts, size, pseudo] = await Promise.all(
+    [
+      computedStyle(cdp, nodeIdOf(related.node)),
+      optionalStyle(related.parent),
+      optionalStyle(related.textHolder),
+      platformFonts(cdp, nodeIdOf(related.node)),
+      platformFonts(cdp, nodeIdOf(related.fontHolder)),
+      borderBoxSize(cdp, related.node),
+      Promise.all(
+        related.pseudo.map(
+          (p) => pseudoSource(cdp, p.type, p.backendNodeId, nodeIdOf(p.backendNodeId))
+        )
       )
-    )
-  ]);
+    ]
+  );
   return {
     style,
     ...parentStyle && { parentStyle },
@@ -17525,16 +17755,20 @@ async function readStyles(cdp, related, params) {
     pseudo,
     fonts: { node: nodeFonts, textHolder: holderFonts },
     ...size && { size },
-    ...matched && { matched }
+    nodeId: nodeIdOf(related.node)
   };
 }
-async function readMatched(cdp, nodeId, params) {
-  const explicit = params.rules === true || params.why !== void 0;
-  const skipped = !explicit && (params.hints === false || params.props !== void 0 || params.all === true);
-  if (nodeId === void 0 || skipped) {
-    return void 0;
+function matchedStylesRead(params) {
+  if (params.rules === true || params.why !== void 0) {
+    return { budgetMs: RULES_BUDGET_MS, skipWhenSlow: false };
   }
-  return matchedStyles(cdp, nodeId, explicit ? RULES_BUDGET_MS : HINTS_BUDGET_MS);
+  if (params.hints === false || params.props !== void 0 || params.all === true) return void 0;
+  return { budgetMs: HINTS_BUDGET_MS, skipWhenSlow: true };
+}
+async function readMatched(cdp, nodeId, params) {
+  const read = matchedStylesRead(params);
+  if (nodeId === void 0 || !read) return void 0;
+  return matchedStyles(cdp, nodeId, read.budgetMs, { skipWhenSlow: read.skipWhenSlow });
 }
 async function pseudoSource(cdp, type, backendNodeId, nodeId) {
   const [style, size] = await Promise.all([
@@ -20381,7 +20615,10 @@ var CLICK_ELEMENT_SCRIPT = `
   else if (el.closest('[inert]')) obstruction = 'inert (the page made it non-interactive)';
   else if (style.pointerEvents === 'none') obstruction = 'not clickable (pointer-events: none)';
   else if (!hasSize) obstruction = 'zero-size';
-  else if (!hittable) obstruction = 'covered by another element' + coveredBy();
+  else if (!hittable) {
+    const collapsed = (${ANCESTOR_CLIP_JS})(el, rect, describe).collapsed;
+    obstruction = collapsed ? 'hidden (' + collapsed + ')' : 'covered by another element' + coveredBy();
+  }
 
   if (action === 'hover') (${REVEAL_SNAPSHOT_JS})(el);
 
@@ -22277,6 +22514,13 @@ function webSocketAsRequest2(connection) {
     webSocket: { frames: connection.frames, ...closedTime !== void 0 && { closedTime } }
   };
 }
+function networkEvictionActivity(store) {
+  const { requestsDropped, bodiesEvicted } = store.networkEvictions;
+  return {
+    ...requestsDropped > 0 && { networkRequestsDropped: requestsDropped },
+    ...bodiesEvicted > 0 && { networkBodiesEvicted: bodiesEvicted }
+  };
+}
 function allNetworkRequests(store) {
   return [
     ...store.networkRequests,
@@ -22403,6 +22647,7 @@ function createCommandRegistry(store, emulation) {
       const totalNetwork = allNetwork.length;
       const totalConsole = store.consoleMessages.length;
       const dropped = store.consoleDropped;
+      const { requestsDropped, bodiesEvicted } = store.networkEvictions;
       const networkBounds = calculateSliceBounds(totalNetwork, lastN, offset);
       const consoleBounds = calculateSliceBounds(totalConsole, lastN, offset);
       const recentNetwork = params.only === "console" ? [] : allNetwork.slice(networkBounds.start, networkBounds.end).map((req) => mapNetworkRequestToPreview(req, params.withHeaders));
@@ -22423,6 +22668,8 @@ function createCommandRegistry(store, emulation) {
         totalNetwork,
         totalConsole,
         ...dropped > 0 && { droppedConsole: dropped },
+        ...requestsDropped > 0 && { droppedNetwork: requestsDropped },
+        ...bodiesEvicted > 0 && { evictedNetworkBodies: bodiesEvicted },
         hasMoreNetwork: networkBounds.start > 0,
         hasMoreConsole: consoleBounds.start > 0
       });
@@ -22457,12 +22704,13 @@ function createCommandRegistry(store, emulation) {
           ...store.pageCrashedAt === void 0 ? await pageAppearance(cdp) : { crashedAt: store.pageCrashedAt }
         },
         activeTelemetry: store.activeTelemetry,
-        activity: filterDefined({
+        activity: {
           networkRequestsCaptured: store.networkRequests.length,
           consoleMessagesCaptured: store.consoleMessages.length,
-          lastNetworkRequestAt: lastNetworkRequest?.timestamp,
-          lastConsoleMessageAt: lastConsoleMessage?.timestamp
-        }),
+          ...lastNetworkRequest && { lastNetworkRequestAt: lastNetworkRequest.timestamp },
+          ...lastConsoleMessage && { lastConsoleMessageAt: lastConsoleMessage.timestamp },
+          ...networkEvictionActivity(store)
+        },
         navigationId: store.getCurrentNavigationId?.() ?? 0
       };
       return result;
@@ -22685,6 +22933,30 @@ function createCommandRegistry(store, emulation) {
   };
 }
 
+// src/daemon/session/matchedStylesReset.ts
+var KEEPS_MATCHED_STYLES = /* @__PURE__ */ new Set([
+  "session_peek",
+  "session_details",
+  "session_status",
+  "session_har_data",
+  "session_network_headers",
+  "dom_frames",
+  "dom_form_discover",
+  "dom_listeners",
+  "dom_layout",
+  "dom_audit",
+  "css_search",
+  "dom_inspect"
+]);
+function withMatchedStylesReset(cdp, name, run) {
+  if (KEEPS_MATCHED_STYLES.has(name)) return run();
+  const reset = () => resetMatchedStyles(cdp);
+  reset();
+  const result = run();
+  void result.then(reset, reset);
+  return result;
+}
+
 // src/daemon/session/teardown.ts
 var CHROME_EXIT_POLL_MS = 50;
 var CHROME_EXIT_POLL_ATTEMPTS = 100;
@@ -23163,7 +23435,8 @@ var Session = class _Session {
    * Execute a registered command against this session. After a renderer
    * crash only {@link RUN_ON_CRASHED_PAGE} commands run (`bdg cdp` only for
    * {@link CRASH_SAFE_CDP} methods); others fail with exit 107 instead of
-   * waiting for a page that cannot answer.
+   * waiting for a page that cannot answer. Commands that may change the page
+   * drop `dom inspect`'s kept matched rules ({@link withMatchedStylesReset}).
    *
    * @param name - Command name
    * @param params - Command parameters
@@ -23179,7 +23452,14 @@ var Session = class _Session {
     if (crashedAt !== void 0 && needsPage) {
       return Promise.reject(pageCrashedCommandError(crashedAt));
     }
-    return this.registry[name](this.cdp, params);
+    if (!Object.hasOwn(this.registry, name)) {
+      return Promise.reject(
+        new CommandError(unknownSessionCommandMessage(name), {}, EXIT_CODES.INVALID_ARGUMENTS)
+      );
+    }
+    const handler = this.registry[name];
+    const cdp = this.cdp;
+    return withMatchedStylesReset(cdp, name, () => handler(cdp, params));
   }
   /**
    * Summary of this session for start responses.
@@ -23759,7 +24039,9 @@ var SessionController = class {
             totals: {
               network: data.totalNetwork,
               console: data.totalConsole,
-              ...data.droppedConsole && { consoleDropped: data.droppedConsole }
+              ...data.droppedConsole && { consoleDropped: data.droppedConsole },
+              ...data.droppedNetwork && { networkDropped: data.droppedNetwork },
+              ...data.evictedNetworkBodies && { networkBodiesEvicted: data.evictedNetworkBodies }
             },
             currentNavigationId: data.currentNavigationId,
             ...data.pageCrashedAt !== void 0 && { pageCrashedAt: data.pageCrashedAt },