browser-debugger-cli 0.14.0 → 0.16.0

package/dist/index.js

@@ -54,6 +54,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 import { readFileSync } from "fs";
 import { createRequire } from "module";
 import { dirname, join } from "path";
+function getBundledProtocolVersion() {
+  const packageJson = JSON.parse(
+    readFileSync(require2.resolve("devtools-protocol/package.json"), "utf-8")
+  );
+  return packageJson.version;
+}
 function loadProtocol() {
   if (cachedProtocol) {
     return cachedProtocol;
@@ -83,6 +89,10 @@ function findCommand(domainName, commandName) {
   const normalized = commandName.toLowerCase();
   return domain.commands.find((c) => c.name.toLowerCase() === normalized);
 }
+function findType(domainName, typeName) {
+  const normalized = typeName.toLowerCase();
+  return findDomain(domainName)?.types?.find((t) => t.id.toLowerCase() === normalized);
+}
 function normalizeMethod(input) {
   const [domainName, commandName] = input.split(".");
   if (!domainName || !commandName) {
@@ -115,6 +125,7 @@ __export(schema_exports, {
   getDomainSummary: () => getDomainSummary,
   getMethodSchema: () => getMethodSchema,
   getProtocolCounts: () => getProtocolCounts,
+  getTypeSchema: () => getTypeSchema,
   searchMethods: () => searchMethods
 });
 function getMethodSchema(domainName, methodName) {
@@ -129,47 +140,86 @@ function getMethodSchema(domainName, methodName) {
   return buildMethodSchema(domain.domain, command);
 }
 function buildMethodSchema(domainName, command) {
-  const parameters = command.parameters?.map(paramToSchema) ?? [];
+  const parameters = command.parameters?.map((p) => paramToSchema(domainName, p)) ?? [];
   const returns = command.returns?.map(returnToSchema) ?? [];
-  const example = {
-    command: `bdg cdp ${domainName}.${command.name}`
-  };
-  if (parameters.length > 0) {
-    const exampleParams = {};
-    parameters.forEach((p) => {
-      if (!p.required) return;
-      exampleParams[p.name] = getExampleValue(p);
-    });
-    if (Object.keys(exampleParams).length > 0) {
-      example.params = exampleParams;
-      example.command += ` --params '${JSON.stringify(exampleParams)}'`;
-    }
-  }
+  const redirect = buildRedirect(command);
+  const exampleSource = parameters.length > 0 ? parameters : redirect?.parameters ?? [];
   const schema = {
     name: `${domainName}.${command.name}`,
     domain: domainName,
     method: command.name,
     parameters,
     returns,
-    example
+    example: buildExample(`${domainName}.${command.name}`, exampleSource)
   };
+  if (redirect) schema.redirect = redirect;
   if (command.description) schema.description = command.description;
   if (command.experimental) schema.experimental = command.experimental;
   if (command.deprecated) schema.deprecated = command.deprecated;
   return schema;
 }
-function paramToSchema(param) {
+function buildRedirect(command) {
+  if (!command.redirect) return void 0;
+  const target = findCommand(command.redirect, command.name);
+  return {
+    method: `${command.redirect}.${command.name}`,
+    resolved: target !== void 0,
+    parameters: target?.parameters?.map((p) => paramToSchema(command.redirect ?? "", p)) ?? []
+  };
+}
+function buildExample(methodName, parameters) {
+  const example = { command: `bdg cdp ${methodName}` };
+  const required = parameters.filter((p) => p.required);
+  if (required.length === 0) return example;
+  const exampleParams = Object.fromEntries(required.map((p) => [p.name, getExampleValue(p)]));
+  example.params = exampleParams;
+  example.command += ` --params '${JSON.stringify(exampleParams)}'`;
+  return example;
+}
+function lookupRef(domainName, ref) {
+  const [refDomain, id] = ref.includes(".") ? ref.split(".") : [domainName, ref];
+  const type = refDomain && id ? findType(refDomain, id) : void 0;
+  return type && { name: `${refDomain}.${type.id}`, type };
+}
+function paramToSchema(domainName, param) {
   const schema = {
     name: param.name,
     type: resolveType(param),
     required: !param.optional
   };
+  const referenced = param.$ref ? lookupRef(domainName, param.$ref) : void 0;
+  const values = param.enum ?? referenced?.type.enum;
   if (param.description) schema.description = param.description;
   if (param.deprecated) schema.deprecated = param.deprecated;
-  if (param.enum) schema.enum = param.enum;
+  if (param.experimental) schema.experimental = param.experimental;
+  if (values) schema.enum = values;
+  if (referenced) {
+    schema.ref = referenced.name;
+    schema.refType = referenced.type.type;
+  }
   if (param.items) schema.items = resolveType(param.items);
   return schema;
 }
+function getTypeSchema(domainName, typeName) {
+  const domain = findDomain(domainName);
+  const type = domain && findType(domain.domain, typeName);
+  if (!domain || !type) return void 0;
+  const schema = {
+    name: `${domain.domain}.${type.id}`,
+    domain: domain.domain,
+    id: type.id,
+    baseType: type.type
+  };
+  if (type.description) schema.description = type.description;
+  if (type.experimental) schema.experimental = type.experimental;
+  if (type.deprecated) schema.deprecated = type.deprecated;
+  if (type.enum) schema.enum = type.enum;
+  if (type.items) schema.items = resolveType(type.items);
+  if (type.properties) {
+    schema.properties = type.properties.map((p) => paramToSchema(domain.domain, p));
+  }
+  return schema;
+}
 function returnToSchema(ret) {
   const schema = {
     name: ret.name,
@@ -190,12 +240,16 @@ function getExampleValue(param) {
   if (param.enum && param.enum.length > 0) {
     return param.enum[0];
   }
-  switch (param.type) {
+  const type = param.refType ?? param.type;
+  const named = Object.hasOwn(EXAMPLE_VALUES, param.name) ? EXAMPLE_VALUES[param.name] : void 0;
+  const namedType = typeof named === "number" ? ["integer", "number"] : ["string"];
+  if (named !== void 0 && namedType.includes(type)) return named;
+  switch (type) {
     case "string":
       return "example";
     case "integer":
     case "number":
-      return 0;
+      return 1;
     case "boolean":
       return true;
     case "array":
@@ -265,11 +319,22 @@ function searchMethods(query) {
   });
   return [...named, ...described];
 }
-var SEARCH_KEYWORDS;
+var EXAMPLE_VALUES, SEARCH_KEYWORDS;
 var init_schema = __esm({
   "src/cdp/schema.ts"() {
     "use strict";
     init_protocol();
+    EXAMPLE_VALUES = {
+      width: 1280,
+      height: 800,
+      x: 100,
+      y: 100,
+      deviceScaleFactor: 1,
+      scale: 1,
+      timeout: 5e3,
+      responseCode: 200,
+      url: "https://example.com"
+    };
     SEARCH_KEYWORDS = {
       "Emulation.setDeviceMetricsOverride": [
         "viewport",
@@ -292,38 +357,6 @@ var init_schema = __esm({
   }
 });
 
-// src/commands/dom/screenshotResize.ts
-function calculateImageTokens(width, height) {
-  return Math.ceil(width * height / PIXELS_PER_TOKEN);
-}
-function calculateResizeScale(width, height) {
-  const longestEdge = Math.max(width, height);
-  if (longestEdge <= MAX_EDGE_PX) {
-    return 1;
-  }
-  return MAX_EDGE_PX / longestEdge;
-}
-function isTallPage(width, height) {
-  if (width === 0) return false;
-  return height / width > TALL_PAGE_THRESHOLD;
-}
-function shouldResize(width, height, noResize) {
-  if (noResize) {
-    return false;
-  }
-  const longestEdge = Math.max(width, height);
-  return longestEdge > MAX_EDGE_PX;
-}
-var MAX_EDGE_PX, PIXELS_PER_TOKEN, TALL_PAGE_THRESHOLD;
-var init_screenshotResize = __esm({
-  "src/commands/dom/screenshotResize.ts"() {
-    "use strict";
-    MAX_EDGE_PX = 1568;
-    PIXELS_PER_TOKEN = 750;
-    TALL_PAGE_THRESHOLD = 3;
-  }
-});
-
 // node_modules/escape-string-regexp/index.js
 var require_escape_string_regexp = __commonJS({
   "node_modules/escape-string-regexp/index.js"(exports, module) {
@@ -960,7 +993,7 @@ var require_node = __commonJS({
     var tty2 = __require("tty");
     var util = __require("util");
     exports.init = init;
-    exports.log = log34;
+    exports.log = log33;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -1095,7 +1128,7 @@ var require_node = __commonJS({
       }
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
-    function log34(...args) {
+    function log33(...args) {
       return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
@@ -1287,14 +1320,14 @@ var require_is_docker = __commonJS({
 var require_is_wsl = __commonJS({
   "node_modules/is-wsl/index.js"(exports, module) {
     "use strict";
-    var os4 = __require("os");
+    var os5 = __require("os");
     var fs19 = __require("fs");
     var isDocker = require_is_docker();
     var isWsl3 = () => {
       if (process.platform !== "linux") {
         return false;
       }
-      if (os4.release().toLowerCase().includes("microsoft")) {
+      if (os5.release().toLowerCase().includes("microsoft")) {
         if (isDocker()) {
           return false;
         }
@@ -1327,7 +1360,7 @@ function resourceTypeFromName(name) {
     ([type, abbreviation]) => type.toLowerCase() === wanted || abbreviation.toLowerCase() === wanted
   )?.[0];
 }
-var HTTP_LOCALHOST, MAX_NETWORK_REQUESTS, MAX_CONSOLE_MESSAGES, MAX_RESPONSE_SIZE, MAX_TOTAL_BODY_BYTES, MAX_VALUE_LENGTH, MAX_CONSOLE_TEXT_LENGTH, MAX_CONSOLE_JSON_TEXT_LENGTH, CHROME_NETWORK_BUFFER_TOTAL, CHROME_NETWORK_BUFFER_PER_RESOURCE, CHROME_POST_DATA_LIMIT, QUERY_JSON_LIST_LIMIT, LAYOUT_ELEMENT_LIMIT, MAX_TRIGGERED_REQUESTS, MAX_JSONL_BUFFER_SIZE, PORT_OPTION_DESCRIPTION, RESOURCE_TYPE_ABBREVIATIONS, MIME_TYPE_RULES;
+var HTTP_LOCALHOST, MAX_NETWORK_REQUESTS, MAX_CONSOLE_MESSAGES, MAX_RESPONSE_SIZE, MAX_TOTAL_BODY_BYTES, MAX_VALUE_LENGTH, MAX_CONSOLE_TEXT_LENGTH, MAX_CONSOLE_JSON_TEXT_LENGTH, CHROME_NETWORK_BUFFER_TOTAL, CHROME_NETWORK_BUFFER_PER_RESOURCE, CHROME_POST_DATA_LIMIT, QUERY_JSON_LIST_LIMIT, EVAL_JSON_ARRAY_LIMIT, LAYOUT_ELEMENT_LIMIT, MAX_TRIGGERED_REQUESTS, MAX_JSONL_BUFFER_SIZE, PORT_OPTION_DESCRIPTION, RESOURCE_TYPE_ABBREVIATIONS, MIME_TYPE_RULES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -1343,6 +1376,7 @@ var init_constants = __esm({
     CHROME_NETWORK_BUFFER_PER_RESOURCE = 10 * 1024 * 1024;
     CHROME_POST_DATA_LIMIT = 1 * 1024 * 1024;
     QUERY_JSON_LIST_LIMIT = 100;
+    EVAL_JSON_ARRAY_LIMIT = 100;
     LAYOUT_ELEMENT_LIMIT = 100;
     MAX_TRIGGERED_REQUESTS = 50;
     MAX_JSONL_BUFFER_SIZE = 256 * 1024 * 1024;
@@ -1421,8 +1455,8 @@ function createLogger(context) {
   logger.debug = (message) => logMessage(message, "debug");
   return logger;
 }
-function logDebugError(log34, context, error) {
-  log34.debug(`Failed to ${context}: ${getErrorMessage(error)}`);
+function logDebugError(log33, context, error) {
+  log33.debug(`Failed to ${context}: ${getErrorMessage(error)}`);
 }
 var debugEnabled;
 var init_logger = __esm({
@@ -1489,11 +1523,30 @@ function makeDirectory(dir, mode) {
   }
   fs2.mkdirSync(dir, { recursive: true, ...mode !== void 0 && { mode } });
 }
-var PSEUDO_FILESYSTEM;
+function dirTrustProblem(dir, options = {}) {
+  const stat = fs2.lstatSync(dir);
+  const problem = (reason, kind) => ({ reason, kind });
+  if (stat.isSymbolicLink()) return problem("it is a symbolic link", "symlink");
+  if (!stat.isDirectory()) return problem("not a directory", "not-directory");
+  const uid = process.getuid?.();
+  if (uid !== void 0 && stat.uid !== uid) return problem(`owned by uid ${stat.uid}`, "owner");
+  if (process.platform === "win32") return null;
+  const writeBits = options.allowGroupWrite ? OTHER_WRITE : GROUP_OTHER_WRITE;
+  if ((stat.mode & writeBits) === 0) return null;
+  const mode = (stat.mode & 4095).toString(8);
+  if ((stat.mode & STICKY) !== 0 && (stat.mode & OTHER_WRITE) !== 0) {
+    return problem(`a shared sticky directory (mode ${mode})`, "shared");
+  }
+  return problem(`writable by others (mode ${mode})`, "writable");
+}
+var PSEUDO_FILESYSTEM, GROUP_OTHER_WRITE, OTHER_WRITE, STICKY;
 var init_directories = __esm({
   "src/utils/directories.ts"() {
     "use strict";
     PSEUDO_FILESYSTEM = /^\/(proc|sys)(\/|$)/;
+    GROUP_OTHER_WRITE = 18;
+    OTHER_WRITE = 2;
+    STICKY = 512;
   }
 });
 
@@ -1502,12 +1555,16 @@ import * as fs3 from "fs";
 import * as os2 from "os";
 import * as path3 from "path";
 function getSessionBaseDir() {
-  const override = process.env[SESSION_DIR_OVERRIDE_ENV];
-  if (override && override.trim().length > 0) {
+  const override = sessionDirOverride();
+  if (override !== null) {
     return path3.isAbsolute(override) ? override : path3.resolve(override);
   }
   return path3.join(os2.homedir(), ".bdg");
 }
+function sessionDirOverride() {
+  const override = process.env[SESSION_DIR_OVERRIDE_ENV];
+  return override && override.trim().length > 0 ? override : null;
+}
 function getSessionName() {
   const name = process.env[SESSION_NAME_ENV]?.trim();
   if (!name) return null;
@@ -1543,14 +1600,84 @@ function getDaemonSocketPath() {
   return getSessionFilePath("DAEMON_SOCKET");
 }
 function ensureSessionDir() {
-  makeDirectory(getSessionDir());
+  makeDirectory(getSessionDir(), PRIVATE_DIR_MODE);
 }
-var log, SESSION_FILES, SESSION_DIR_OVERRIDE_ENV, SESSION_NAME_ENV, NAMED_SESSIONS_DIR, MAX_SOCKET_PATH_BYTES, MAX_DAEMON_SOCKET_PATH_BYTES, SESSION_STATE_FILES;
+function getSessionDownloadsDir() {
+  return path3.join(getSessionDir(), DOWNLOADS_DIR);
+}
+function sessionDirChain(dir) {
+  const base = getSessionBaseDir();
+  const relative2 = path3.relative(base, dir);
+  if (relative2 === ".." || relative2.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative2)) {
+    return [{ dir, bdgOwned: false, isBase: false }];
+  }
+  const chain = [{ dir: base, bdgOwned: sessionDirOverride() === null, isBase: true }];
+  let current = base;
+  for (const part of relative2.split(path3.sep).filter(Boolean)) {
+    current = path3.join(current, part);
+    chain.push({ dir: current, bdgOwned: true, isBase: false });
+  }
+  return chain;
+}
+function tightenDir(dir) {
+  if (process.platform === "win32") return;
+  let fd;
+  try {
+    const { O_RDONLY, O_DIRECTORY, O_NOFOLLOW } = fs3.constants;
+    fd = fs3.openSync(dir, O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+    const stat = fs3.fstatSync(fd);
+    if (stat.uid !== process.getuid?.() || (stat.mode & GROUP_OTHER_ACCESS) === 0) return;
+    fs3.fchmodSync(fd, PRIVATE_DIR_MODE);
+    log.debug(`Session directory ${dir} restricted to mode 700`);
+  } catch (error) {
+    log.debug(`Session directory ${dir} not restricted: ${getErrorMessage(error)}`);
+  } finally {
+    if (fd !== void 0) fs3.closeSync(fd);
+  }
+}
+function chainDirProblem(entry) {
+  const problem = dirTrustProblem(entry.dir, SESSION_DIR_TRUST);
+  if (problem?.kind !== "symlink" || !entry.isBase) return problem;
+  const target = fs3.realpathSync(entry.dir);
+  const targetProblem = dirTrustProblem(target, SESSION_DIR_TRUST);
+  return targetProblem && {
+    ...targetProblem,
+    reason: `it links to ${target}, which is ${targetProblem.reason}`
+  };
+}
+function acceptTrustedDir(entry) {
+  if (entry.bdgOwned) {
+    tightenDir(entry.dir);
+    return;
+  }
+  const mode = fs3.statSync(entry.dir, { throwIfNoEntry: false })?.mode ?? 0;
+  if ((mode & GROUP_OTHER_ACCESS) === 0) return;
+  log.debug(
+    `Session directory ${entry.dir} is open to group or others; left as is (chosen with ${SESSION_DIR_OVERRIDE_ENV})`
+  );
+}
+function secureSessionDir(dir = getSessionDir()) {
+  for (const entry of sessionDirChain(dir)) {
+    let problem;
+    try {
+      problem = chainDirProblem(entry);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") continue;
+      problem = { reason: getErrorMessage(error), kind: "not-directory" };
+    }
+    if (problem !== null) return { dir: entry.dir, ...problem, bdgOwned: entry.bdgOwned };
+    acceptTrustedDir(entry);
+  }
+  return null;
+}
+var log, SESSION_FILES, SESSION_DIR_OVERRIDE_ENV, SESSION_NAME_ENV, NAMED_SESSIONS_DIR, MAX_SOCKET_PATH_BYTES, MAX_DAEMON_SOCKET_PATH_BYTES, SESSION_STATE_FILES, PRIVATE_DIR_MODE, GROUP_OTHER_ACCESS, DOWNLOADS_DIR, SESSION_DIR_TRUST;
 var init_paths = __esm({
   "src/session/paths.ts"() {
     "use strict";
     init_logging();
     init_directories();
+    init_errors();
     log = createLogger("session");
     SESSION_FILES = {
       OUTPUT: "session.json",
@@ -1572,6 +1699,10 @@ var init_paths = __esm({
       "CHROME_PID",
       "METADATA"
     ];
+    PRIVATE_DIR_MODE = 448;
+    GROUP_OTHER_ACCESS = 63;
+    DOWNLOADS_DIR = "downloads";
+    SESSION_DIR_TRUST = { allowGroupWrite: true };
   }
 });
 
@@ -1653,14 +1784,17 @@ var init_atomicFile = __esm({
        *
        * @param filePath - Target file path
        * @param data - Data to write
-       * @param options - Write options
+       * @param options - Write options (`mode`: permissions of the new file, less the umask)
        * @returns Promise that resolves when write completes
        * @throws Error if write operation fails
        */
       static async writeAsync(filePath, data, options = {}) {
         const tmpPath = this.getTempPath(filePath);
         try {
-          await fs4.promises.writeFile(tmpPath, data, { encoding: options.encoding ?? "utf-8" });
+          await fs4.promises.writeFile(tmpPath, data, {
+            encoding: options.encoding ?? "utf-8",
+            ...options.mode !== void 0 && { mode: options.mode }
+          });
           await fs4.promises.rename(tmpPath, filePath);
         } catch (error) {
           try {
@@ -1703,48 +1837,6 @@ var init_atomicFile = __esm({
   }
 });
 
-// src/session/metadata.ts
-import * as fs8 from "fs";
-function handleCorruptedMetadata(metaPath, error, options) {
-  if (options?.warnOnCorruption) {
-    log6.info(`Session metadata corrupted (cannot read details): ${getErrorMessage(error)}`);
-    log6.info(`Troubleshooting: Run "${sessionCommand("bdg cleanup")}" to remove corrupted files`);
-  }
-  if (options?.selfHealOnCorruption) {
-    try {
-      fs8.rmSync(metaPath, { force: true });
-      log6.info("Removed corrupted session metadata file");
-    } catch (deleteError) {
-      log6.debug(`Failed to remove corrupted metadata: ${getErrorMessage(deleteError)}`);
-    }
-  }
-}
-function readSessionMetadata(options) {
-  const metaPath = getSessionFilePath("METADATA");
-  if (!fs8.existsSync(metaPath)) {
-    return null;
-  }
-  try {
-    const content = fs8.readFileSync(metaPath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    handleCorruptedMetadata(metaPath, error, options);
-    return null;
-  }
-}
-var log6;
-var init_metadata = __esm({
-  "src/session/metadata.ts"() {
-    "use strict";
-    init_logging();
-    init_sessionCommand();
-    init_atomicFile();
-    init_errors();
-    init_paths();
-    log6 = createLogger("session");
-  }
-});
-
 // src/utils/validation.ts
 function valid() {
   return { valid: true };
@@ -2041,6 +2133,10 @@ function formatDuration(ms) {
   }
   return `${ms}ms`;
 }
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
 var hintsHidden, OutputFormatter, MIN_URL_END_SHOWN, WEB_PROTOCOLS;
 var init_formatting = __esm({
   "src/ui/formatting.ts"() {
@@ -2192,13 +2288,22 @@ function chromeClosedMessage(pid) {
 function orphanedDaemonsCleanedMessage(count) {
   return `Cleaned up ${count} orphaned daemon process${count === 1 ? "" : "es"}`;
 }
-function skillBackupMessage(path7) {
-  return `previous copy kept in ${path7}`;
+function skillBackupMessage(path8) {
+  return `previous copy kept in ${path8}`;
 }
 function fieldLabelList(labels) {
   const shown = labels.slice(0, 5).map((label) => label.replace(/\s*:\s*$/, "")).join(", ");
   return labels.length > 5 ? `${shown} and ${labels.length - 5} more` : shown;
 }
+function cdpUnlistedMethodWarning(method, protocolVersion) {
+  return `${method} is not in the bundled protocol (devtools-protocol ${protocolVersion}); sending it to Chrome as is`;
+}
+function cdpUnresolvedRedirectLine(method) {
+  return `Redirect target ${method} is not in the protocol (unresolved redirect)`;
+}
+function cdpRedirectTitle(method) {
+  return `Implemented by ${method} (redirect)`;
+}
 function requiredFieldsEmptyMessage(labels) {
   const fields = labels.length === 1 ? "field" : "fields";
   return `${labels.length} required ${fields} empty: ${fieldLabelList(labels)}`;
@@ -2235,6 +2340,19 @@ function pageNavigationText(navigation) {
   const status = navigation.status === void 0 ? "" : ` (${navigation.status})`;
   return `navigated to ${navigation.url}${status}`;
 }
+function downloadText(download) {
+  const where = download.path === void 0 ? "" : ` \u2192 ${download.path}`;
+  const running = download.state === "inProgress";
+  const bytes = download.bytes === void 0 || running && download.bytes === 0 ? "" : `, ${formatBytes(download.bytes)}${running ? " so far" : ""}`;
+  const reason = download.reason === void 0 ? "" : `: ${download.reason}`;
+  return `Download: ${download.suggestedFilename}${where} (${download.state}${bytes}${reason})`;
+}
+function downloadsSummary(downloads) {
+  const last = downloads[downloads.length - 1];
+  if (!last) return "0";
+  const where = last.path === void 0 ? "" : ` \u2192 ${last.path}`;
+  return `${downloads.length} (last: ${last.suggestedFilename}${where}, ${last.state})`;
+}
 function moreMessagesText(count) {
   return `(+${count} more)`;
 }
@@ -2535,6 +2653,9 @@ function sessionFilesCleanedMessage() {
 function sessionOutputRemovedMessage() {
   return "Session output file removed";
 }
+function downloadsKeptMessage(dir, files) {
+  return `Downloads kept: ${pluralize(files, "file")} in ${dir} (delete them yourself when done)`;
+}
 function sessionDirectoryCleanMessage() {
   return "Session directory is now clean";
 }
@@ -2598,7 +2719,7 @@ function helpJsonDetailsNote() {
 function moreCharsNote(count) {
   return `\u2026 ${count} more chars (use --full)`;
 }
-var REQUIRED_FIELD_EMPTY_REASON, NO_VISIBLE_EFFECT, HOVER_OFF_DONE, HOVER_USAGE, LAYOUT_REASONS, SCROLL_LOCKED_PREFIX, VIEWPORT_POSITION_HINTS, INSPECT_OUTPUT_LEGEND, COLLAPSED_LISTENERS_HEADING, NO_LISTENERS_HINT, NOTE_TYPES_SHOWN, POINTER_ACTION_DONE, POINTER_ACTION_NOUN, PAGE_ACTION_DONE, PAGE_INFO_DESCRIPTION, PAGE_EMULATE_DESCRIPTION, PAGE_ACTION_DESCRIPTIONS, CLICK_RESULT_WAIT_HELP, WAIT_HELP_EXAMPLES, FRAME_URL_MAX_LENGTH, AUDIT_HELP_EXAMPLES, CSS_SEARCH_HELP_EXAMPLES;
+var REQUIRED_FIELD_EMPTY_REASON, CDP_EXECUTION_HELP, NO_VISIBLE_EFFECT, HOVER_OFF_DONE, HOVER_USAGE, LAYOUT_REASONS, SCROLL_LOCKED_PREFIX, VIEWPORT_POSITION_HINTS, INSPECT_OUTPUT_LEGEND, COLLAPSED_LISTENERS_HEADING, NO_LISTENERS_HINT, NOTE_TYPES_SHOWN, POINTER_ACTION_DONE, POINTER_ACTION_NOUN, PAGE_ACTION_DONE, PAGE_INFO_DESCRIPTION, PAGE_EMULATE_DESCRIPTION, PAGE_ACTION_DESCRIPTIONS, CLICK_RESULT_WAIT_HELP, WAIT_HELP_EXAMPLES, FRAME_URL_MAX_LENGTH, AUDIT_HELP_EXAMPLES, CSS_SEARCH_HELP_EXAMPLES;
 var init_commands = __esm({
   "src/ui/messages/commands.ts"() {
     "use strict";
@@ -2607,6 +2728,7 @@ var init_commands = __esm({
     init_sessionCommand();
     init_strings();
     REQUIRED_FIELD_EMPTY_REASON = "Required field is empty";
+    CDP_EXECUTION_HELP = "  Execution: bundled methods are case-insensitive (network.getcookies works)\n  Other methods are sent as typed (case-sensitive)";
     NO_VISIBLE_EFFECT = "no visible effect observed: no DOM change, requests or navigation within 300 ms";
     HOVER_OFF_DONE = "\u2713 Mouse moved off the page (hover styles and menus that close on mouseleave are gone)";
     HOVER_USAGE = "bdg dom hover <selector|index>, or bdg dom hover --off to move the mouse away";
@@ -2911,7 +3033,7 @@ var init_CommandError = __esm({
 });
 
 // src/ipc/transport/IPCError.ts
-var IPCError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError;
+var IPCError, IPCConnectionError, IPCTimeoutError, IPCParseError, IPCEarlyCloseError, IPCCancelledError;
 var init_IPCError = __esm({
   "src/ipc/transport/IPCError.ts"() {
     "use strict";
@@ -2969,6 +3091,14 @@ var init_IPCError = __esm({
         this.requestName = requestName;
       }
     };
+    IPCCancelledError = class extends IPCError {
+      name = "IPCCancelledError";
+      requestName;
+      constructor(requestName) {
+        super(`${requestName} request cancelled`, EXIT_CODES.SOFTWARE_ERROR);
+        this.requestName = requestName;
+      }
+    };
   }
 });
 
@@ -3120,6 +3250,7 @@ var init_shellDetection = __esm({
 });
 
 // src/errors/messages.ts
+import * as os3 from "os";
 import * as path4 from "path";
 function sessionAlreadyRunningError(pid, duration, targetUrl) {
   return joinLines(
@@ -3170,6 +3301,12 @@ function commandTimedOutError(seconds) {
     suggestion: `Check the session with: ${sessionCommand("bdg status")}; if the page stays frozen, end it with: ${sessionCommand("bdg cleanup --force")}`
   };
 }
+function screenshotInterruptedError(signal) {
+  return {
+    message: `Screenshot cancelled (${signal === "SIGINT" ? "interrupted" : "terminated"})`,
+    suggestion: "No file was written; run it again to capture (the next command sees the page's own emulation)"
+  };
+}
 function sessionUnavailableSuggestion(exitCode) {
   return exitCode === 85 ? `Wait until "${sessionCommand("bdg <url>")}" returns, then retry` : startSessionSuggestion();
 }
@@ -3291,8 +3428,13 @@ function unknownHelpTopicError(topic, closest) {
     suggestion: closest ? `Did you mean: bdg help ${closest}?` : `Run "bdg ${parent ? `${parent} ` : ""}--help" for commands`
   };
 }
-function usageHelpSuggestion(path7) {
-  return `Run "${path7} --help" for usage`;
+function didYouMeanSuggestion(candidates) {
+  const last = candidates.at(-1) ?? "";
+  const rest = candidates.slice(0, -1);
+  return `Did you mean: ${rest.length > 0 ? `${rest.join(", ")} or ${last}` : last}?`;
+}
+function usageHelpSuggestion(path8) {
+  return `Run "${path8} --help" for usage`;
 }
 function missingSubcommandMessage() {
   return "Missing subcommand";
@@ -3349,7 +3491,7 @@ function invalidSessionNameError(name, maxLength) {
 function sessionNameSocketTooLongError(name, socketPath, max) {
   return {
     message: `Session name "${name}" makes the daemon socket path too long (${Buffer.byteLength(socketPath)} bytes, at most ${max}): ${socketPath}`,
-    suggestion: "Use a shorter session name, or a shorter BDG_SESSION_DIR (e.g. /tmp/bdg)"
+    suggestion: `Use a shorter session name, or a shorter BDG_SESSION_DIR (e.g. ${privateSessionDirExample()})`
   };
 }
 function purgeNeedsNamedSessionError() {
@@ -3364,19 +3506,52 @@ function purgeRefusedError(dir, reason) {
     suggestion: `End the session first (${sessionCommand("bdg cleanup --force")}), then retry: ${sessionCommand("bdg cleanup --purge")}`
   };
 }
+function privateSessionDirExample() {
+  const runtimeDir = process.env["XDG_RUNTIME_DIR"]?.trim();
+  if (runtimeDir) return path4.join(runtimeDir, "bdg");
+  const uid = process.getuid?.();
+  return path4.join(os3.tmpdir(), uid === void 0 ? "bdg" : `bdg-${uid}`);
+}
+function sessionDirSuggestion() {
+  return `Set BDG_SESSION_DIR to a short directory only you can write to, e.g. BDG_SESSION_DIR=${privateSessionDirExample()}`;
+}
 function sessionDirIsFileError(dir) {
-  return { message: `Session directory ${dir} is a file`, suggestion: SESSION_DIR_SUGGESTION };
+  return { message: `Session directory ${dir} is a file`, suggestion: sessionDirSuggestion() };
 }
 function sessionDirNotWritableError(dir, reason) {
   return {
     message: `Session directory ${dir} is not writable (${reason})`,
-    suggestion: SESSION_DIR_SUGGESTION
+    suggestion: sessionDirSuggestion()
+  };
+}
+function untrustedSessionDirError(untrusted) {
+  return {
+    message: `Session directory ${untrusted.dir} is not safe to use: ${untrusted.reason}`,
+    suggestion: untrustedSessionDirSuggestion(untrusted)
+  };
+}
+function untrustedSessionDirSuggestion(untrusted) {
+  const { dir, kind, bdgOwned } = untrusted;
+  const example = `BDG_SESSION_DIR=${privateSessionDirExample()}`;
+  if (kind === "symlink") {
+    return `Remove the link (rm ${dir}) or point BDG_SESSION_DIR at the real directory`;
+  }
+  if (kind === "shared") {
+    return `${dir} is shared by all users; use a subdirectory only you can write to, e.g. ${example}`;
+  }
+  if (bdgOwned) return `Run chmod 700 ${dir} (or remove it if it is not yours), then retry`;
+  return `Use a directory you own that others cannot write to, e.g. ${example} (or chmod 700 ${dir} if it is yours)`;
+}
+function daemonLogNotOpenedError(logPath, code) {
+  return {
+    message: `Cannot open the daemon log ${logPath} (${code === "ELOOP" ? "it is a symbolic link" : code})`,
+    suggestion: `Remove ${logPath} if you did not create it, then retry`
   };
 }
 function socketPathTooLongError(socketPath, max) {
   return {
     message: `Session directory path is too long for the daemon socket (${Buffer.byteLength(socketPath)} bytes, at most ${max}): ${socketPath}`,
-    suggestion: SESSION_DIR_SUGGESTION
+    suggestion: sessionDirSuggestion()
   };
 }
 function externalChromeUnreachableError(endpoint, secure) {
@@ -3575,18 +3750,6 @@ function waitTargetRequiredError() {
     suggestion: `e.g. ${sessionCommand("bdg dom wait '#result' --visible")}, ${sessionCommand("bdg dom wait body --text 'Welcome'")} or ${sessionCommand("bdg dom wait --load")}`
   };
 }
-function elementNotVisibleError() {
-  return {
-    message: "Element is not rendered (e.g. display: none), so it has no area to capture",
-    suggestion: "Make it visible first, or capture a visible ancestor"
-  };
-}
-function elementZeroDimensionsError() {
-  return {
-    message: "Element has zero width or height, so there is nothing to capture",
-    suggestion: "It may be collapsed or empty; capture a visible ancestor instead"
-  };
-}
 function hoverOffWithTargetError() {
   return {
     message: "--off moves the mouse off the page; it takes no element",
@@ -3709,16 +3872,44 @@ function formInIframeError(iframeUrl, crossOrigin) {
     suggestion: crossOrigin ? "Cross-origin iframes cannot be read or controlled; open the iframe URL directly: bdg <iframe url>" : 'dom form lists forms of the main document only; its fields are reachable directly: bdg dom query "input, select, textarea", then bdg dom fill <index> <value>'
   };
 }
+function cdpTypeNotMethodError(name) {
+  return {
+    message: `${name} is a protocol type, not a method`,
+    suggestion: `Use: bdg cdp ${name} --describe (to see its values or properties)`
+  };
+}
+function cdpMethodNotFoundError(input, similar, listHint) {
+  const didYouMean = similar.length > 0 ? ["", "Did you mean:", ...similar.map((name) => `  - ${name}`)] : [];
+  return {
+    message: `Method '${input}' not found`,
+    suggestion: [listHint, ...didYouMean].join("\n")
+  };
+}
+function cdpMethodTypoError(input, similar, listHint) {
+  const err = cdpMethodNotFoundError(input, similar, listHint);
+  return {
+    message: err.message,
+    suggestion: `${err.suggestion}
+
+To send it as typed (a method newer than bdg's protocol): ${sessionCommand(`bdg cdp ${input} --send-anyway`)}`
+  };
+}
+function cdpMethodNotInBundledProtocolError(method, protocolVersion) {
+  return {
+    message: `Method '${method}' is not in the bundled protocol (devtools-protocol ${protocolVersion})`,
+    suggestion: `bdg cdp ${method} sends it to Chrome as is, which may still have it. Methods bdg knows: bdg cdp --search <keyword>`
+  };
+}
 function skillSourceMissingError(source) {
   return {
     message: `The bdg skill is missing from the installed package (${source})`,
     suggestion: "Reinstall bdg: npm install -g browser-debugger-cli"
   };
 }
-function skillWriteFailedError(path7, reason, pathIsFile, otherTargetFlag) {
+function skillWriteFailedError(path8, reason, pathIsFile, otherTargetFlag) {
   const fix = pathIsFile ? "A part of that path is a file, not a directory: move it away" : "Check the permissions of that directory";
   return {
-    message: `Could not write ${path7}: ${reason}`,
+    message: `Could not write ${path8}: ${reason}`,
     suggestion: otherTargetFlag ? `${fix}, or install for the other agent only (${otherTargetFlag})` : fix
   };
 }
@@ -3731,7 +3922,7 @@ function intervalWithoutFollowError() {
 function unknownAuditCheckMessage(value, similar, checks) {
   return `Unknown check "${value}"${similar.length > 0 ? `; did you mean ${similar[0]}?` : ""} (checks: ${checks.join(", ")})`;
 }
-var LAUNCHED_CHROME_DESCRIPTION, A11Y_NAME_QUERY_EXAMPLE, SCOPED_FILTER_EXAMPLES, PLAYWRIGHT_ONLY_SYNTAX, MALFORMED_SELECTOR_DETAILS, SESSION_DIR_SUGGESTION, SCROLL_PROBLEMS, VIA_LABEL_SUFFIX, NAME_QUERY_PLACEHOLDER, LABEL_WITHOUT_CONTROL, REDECLARED_PATTERN;
+var LAUNCHED_CHROME_DESCRIPTION, A11Y_NAME_QUERY_EXAMPLE, SCOPED_FILTER_EXAMPLES, PLAYWRIGHT_ONLY_SYNTAX, MALFORMED_SELECTOR_DETAILS, SCROLL_PROBLEMS, VIA_LABEL_SUFFIX, NAME_QUERY_PLACEHOLDER, LABEL_WITHOUT_CONTROL, REDECLARED_PATTERN;
 var init_messages = __esm({
   "src/errors/messages.ts"() {
     "use strict";
@@ -3752,7 +3943,6 @@ var init_messages = __esm({
       "empty-has": () => ":has() has an empty selector",
       "scope-in-has": () => ":has() with filters is already relative to the element; write :has(> a:visible) instead of :has(:scope > a:visible)"
     };
-    SESSION_DIR_SUGGESTION = "Set BDG_SESSION_DIR to a short, writable directory, e.g. BDG_SESSION_DIR=/tmp/bdg";
     SCROLL_PROBLEMS = {
       "index-without-selector": [
         "--index requires a selector",
@@ -3886,6 +4076,47 @@ var init_suggestions = __esm({
   }
 });
 
+// src/commands/shared/interrupt.ts
+function interruptExitCode(signal) {
+  return signal === "SIGINT" ? EXIT_CODES.INTERRUPTED : EXIT_CODES.TERMINATED;
+}
+function interruptSignal(interrupt) {
+  return interrupt.reason === "SIGTERM" ? "SIGTERM" : "SIGINT";
+}
+function abortOnInterrupt() {
+  const interrupt = new AbortController();
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      if (interrupt.signal.aborted) process.exit(interruptExitCode(signal));
+      interrupt.abort(signal);
+    });
+  }
+  return interrupt.signal;
+}
+async function unlessInterrupted(work, interrupt, interruptedError) {
+  const fail = () => interruptedError(interruptSignal(interrupt));
+  if (interrupt.aborted) throw fail();
+  let onAbort = () => void 0;
+  const interrupted = new Promise((_, reject2) => {
+    onAbort = () => reject2(fail());
+    interrupt.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([work, interrupted]);
+  } catch (error) {
+    if (interrupt.aborted) throw fail();
+    throw error;
+  } finally {
+    interrupt.removeEventListener("abort", onAbort);
+  }
+}
+var init_interrupt = __esm({
+  "src/commands/shared/interrupt.ts"() {
+    "use strict";
+    init_exitCodes();
+  }
+});
+
 // src/ipc/transport/errors.ts
 function formatConnectionError(requestName, socketPath, error) {
   const code = error.code;
@@ -3907,6 +4138,9 @@ function formatTimeoutError(requestName, timeoutMs) {
 function formatEarlyCloseError(requestName) {
   return new IPCEarlyCloseError(requestName);
 }
+function formatCancelledError(requestName) {
+  return new IPCCancelledError(requestName);
+}
 var init_errors4 = __esm({
   "src/ipc/transport/errors.ts"() {
     "use strict";
@@ -4075,13 +4309,30 @@ var init_validation2 = __esm({
 });
 
 // src/ipc/transport/index.ts
-async function sendRequest(request, requestName, expectedType, timeoutMs = getIPCRequestTimeout(), socketPath = getDaemonSocketPath()) {
+import * as path5 from "path";
+async function sendRequest(request, requestName, expectedType, timeoutMs = getIPCRequestTimeout(), socketPath = getDaemonSocketPath(), signal) {
+  const untrusted = secureSessionDir(path5.dirname(socketPath));
+  if (untrusted) {
+    const err = untrustedSessionDirError(untrusted);
+    throw new CommandError(
+      err.message,
+      { suggestion: err.suggestion },
+      EXIT_CODES.SESSION_FILE_ERROR
+    );
+  }
   return new Promise((resolve4, reject2) => {
+    if (signal?.aborted) {
+      reject2(formatCancelledError(requestName));
+      return;
+    }
     const buffer = new JSONLBuffer();
     let resolved = false;
+    let onAbort = () => {
+    };
     const resolveOnce = (cleanup2, error, response) => {
       if (resolved) return;
       resolved = true;
+      signal?.removeEventListener("abort", onAbort);
       cleanup2();
       if (error) {
         reject2(error);
@@ -4127,6 +4378,8 @@ async function sendRequest(request, requestName, expectedType, timeoutMs = getIP
         }
       }
     );
+    onAbort = () => resolveOnce(cleanup, formatCancelledError(requestName));
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
 var log10;
@@ -4134,8 +4387,11 @@ var init_transport = __esm({
   "src/ipc/transport/index.ts"() {
     "use strict";
     init_constants();
+    init_errors3();
+    init_messages();
     init_paths();
     init_logging();
+    init_exitCodes();
     init_errors4();
     init_jsonl();
     init_socket();
@@ -4231,7 +4487,7 @@ async function getHARData() {
   await assertResponsive();
   return sendRequest(request, "HAR data", "har_data_response");
 }
-async function startSession(url, options) {
+async function startSession(url, options, signal) {
   const request = withSession({
     type: "start_session_request",
     url,
@@ -4253,7 +4509,10 @@ async function startSession(url, options) {
   return sendRequest(
     request,
     "start session",
-    "start_session_response"
+    "start_session_response",
+    void 0,
+    void 0,
+    signal
   );
 }
 async function stopSession() {
@@ -4265,7 +4524,7 @@ async function stopSession() {
     "stop_session_response"
   );
 }
-async function sendCommand(commandName, params, timeoutMs) {
+async function sendCommand(commandName, params, timeoutMs, signal) {
   const request = {
     ...params,
     type: `${commandName}_request`,
@@ -4276,7 +4535,9 @@ async function sendCommand(commandName, params, timeoutMs) {
     request,
     commandName,
     `${commandName}_response`,
-    timeoutMs
+    timeoutMs,
+    void 0,
+    signal
   );
 }
 async function getDetails(type, id) {
@@ -4311,8 +4572,12 @@ async function callCDP(method, params, options = {}) {
 function callBdgScript(method, params) {
   return callCDP(method, params, { isolated: true });
 }
-async function domEval(script, frame) {
-  return sendCommand("dom_eval", { script, ...frame !== void 0 && { frame } });
+async function domEval(script, frame, full) {
+  return sendCommand("dom_eval", {
+    script,
+    ...frame !== void 0 && { frame },
+    ...full && { full }
+  });
 }
 async function domFrames() {
   return sendCommand("dom_frames", {});
@@ -4356,6 +4621,9 @@ async function cssSearch(params) {
 async function domInspect(params) {
   return sendCommand("dom_inspect", params);
 }
+async function domScreenshot(params, signal) {
+  return sendCommand("dom_screenshot", params, void 0, signal);
+}
 async function domWait(params) {
   return sendCommand(
     "dom_wait",
@@ -4376,36 +4644,6 @@ var init_client = __esm({
   }
 });
 
-// src/connection/errors.ts
-var ConnectionError, CDPConnectionError;
-var init_errors5 = __esm({
-  "src/connection/errors.ts"() {
-    "use strict";
-    init_exitCodes();
-    ConnectionError = class extends Error {
-      issue;
-      constructor(message, options) {
-        super(message);
-        this.name = this.constructor.name;
-        if (options instanceof Error) {
-          this.cause = options;
-          return;
-        }
-        if (options?.cause) {
-          this.cause = options.cause;
-        }
-        if (options?.issue) {
-          this.issue = options.issue;
-        }
-      }
-    };
-    CDPConnectionError = class extends ConnectionError {
-      code = "CDP_CONNECTION_ERROR";
-      exitCode = EXIT_CODES.CDP_CONNECTION_FAILURE;
-    };
-  }
-});
-
 // node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "node_modules/ws/lib/constants.js"(exports, module) {
@@ -8109,7 +8347,7 @@ function textPreview2(text, length = PREVIEW_LENGTH) {
   const characters = Array.from(collapsed);
   return characters.length > length ? characters.slice(0, length).join("") + "..." : collapsed;
 }
-var CLASS_FRAGMENT, LABEL_CLASSES_JS, PREVIEW_LENGTH, ELEMENT_TEXT_LENGTH, WITHOUT_DECORATIONS_JS, COMPOSED_JS, FLAT_TEXT_JS, ELEMENT_TEXT_JS, MASKED_VALUE, SENSITIVE_FIELD_JS, ELEMENT_STATE_JS, ELEMENT_DESCRIPTION_JS, SIBLING_POSITION_JS, ELEMENT_IDENTITY_JS, ELEMENT_CONTEXT_JS;
+var CLASS_FRAGMENT, LABEL_CLASSES_JS, PREVIEW_LENGTH, ELEMENT_TEXT_LENGTH, WITHOUT_DECORATIONS_JS, COMPOSED_JS, FLAT_TEXT_JS, ELEMENT_TEXT_JS, MASKED_VALUE, SENSITIVE_NAME_SOURCE, SENSITIVE_FIELD_JS, ELEMENT_STATE_JS, ELEMENT_DESCRIPTION_JS, SIBLING_POSITION_JS, ELEMENT_IDENTITY_JS, ELEMENT_CONTEXT_JS;
 var init_elementInfo = __esm({
   "src/runtime/dom/elementInfo.ts"() {
     "use strict";
@@ -8200,12 +8438,13 @@ var init_elementInfo = __esm({
   return withoutDecorations(el, start);
 }`;
     MASKED_VALUE = "\u2022\u2022\u2022\u2022";
+    SENSITIVE_NAME_SOURCE = "passw|passwd|pwd|passcode|passphrase|(^|[^a-z])(otp|pin|ssn)([^a-z]|$)|cvv|cvc|card[-_]?(num(ber)?|no)([^a-z]|$)";
     SENSITIVE_FIELD_JS = `(el) => {
   const autocomplete = el.getAttribute('autocomplete') || '';
   if (/(^|\\s)(cc-[a-z-]+|one-time-code|current-password|new-password)(\\s|$)/i.test(autocomplete)) return true;
   if (el.type === 'password' || /^password$/i.test(el.getAttribute('type') || '')) return true;
   const names = [el.getAttribute('name'), el.id, autocomplete].join(' ');
-  if (/passw|passwd|pwd|passcode|(^|[^a-z])otp([^a-z]|$)|cvv|cvc/i.test(names)) return true;
+  if (/${SENSITIVE_NAME_SOURCE}/i.test(names)) return true;
   try {
     const security = el.ownerDocument.defaultView.getComputedStyle(el).getPropertyValue('-webkit-text-security');
     return Boolean(security) && security !== 'none';
@@ -8990,10 +9229,10 @@ function findHasFilters(text, selector) {
 }
 function parseHasArgument(argument, selector) {
   if (!FILTER_NAME_HINT.test(argument)) return null;
-  const selectors = splitSelectorList(argument).map((relative) => {
-    if (relative.trim() === "") reject(malformedSelectorError(selector, "empty-has"));
-    if (SCOPE_PSEUDO.test(relative)) reject(malformedSelectorError(selector, "scope-in-has"));
-    const { leading, steps } = parseChain(relative, selector);
+  const selectors = splitSelectorList(argument).map((relative2) => {
+    if (relative2.trim() === "") reject(malformedSelectorError(selector, "empty-has"));
+    if (SCOPE_PSEUDO.test(relative2)) reject(malformedSelectorError(selector, "scope-in-has"));
+    const { leading, steps } = parseChain(relative2, selector);
     if (leading && leading !== ">") reject(siblingInHasError(selector, leading));
     const [first, ...rest] = steps;
     return first ? [{ ...first, combinator: leading || " " }, ...rest] : [];
@@ -9673,7 +9912,7 @@ async function resolveSelector(selector) {
       EXIT_CODES.RESOURCE_NOT_FOUND
     );
   }
-  return { backendNodeId };
+  return backendNodeId;
 }
 async function resolveBackendNodeIds(selectors) {
   return mapConcurrently(selectors, async (selector) => (await selectAll(selector))[0]);
@@ -9761,7 +10000,7 @@ var init_query = __esm({
 
 // src/commands/shared/outputFile.ts
 import * as fs15 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 function outputPathError(filePath, error, extension2) {
   const code = error.code ?? "";
   const problem = PATH_PROBLEMS[code];
@@ -9790,13 +10029,16 @@ function assertFilePath(filePath, extension2) {
     );
   }
 }
-async function writeOutputFile(filePath, data, extension2) {
+async function writeOutputFile(filePath, data, extension2, mode) {
   assertFilePath(filePath, extension2);
-  const absolutePath = path5.resolve(filePath);
+  const absolutePath = path6.resolve(filePath);
   try {
-    makeDirectory(path5.dirname(absolutePath));
-    if (typeof data === "string") await AtomicFileWriter.writeAsync(absolutePath, data);
-    else await AtomicFileWriter.writeBufferAsync(absolutePath, data);
+    makeDirectory(path6.dirname(absolutePath));
+    if (typeof data === "string") {
+      await AtomicFileWriter.writeAsync(absolutePath, data, mode === void 0 ? {} : { mode });
+    } else {
+      await AtomicFileWriter.writeBufferAsync(absolutePath, data);
+    }
   } catch (error) {
     throw outputPathError(filePath, error, extension2);
   }
@@ -9829,575 +10071,45 @@ var init_outputFile = __esm({
   }
 });
 
-// src/runtime/page/userAgent.ts
-var init_userAgent = __esm({
-  "src/runtime/page/userAgent.ts"() {
-    "use strict";
-    init_errors();
-  }
-});
-
-// src/runtime/page/emulation.ts
-function viewportOverride(viewport, deviceScaleFactor = 0) {
-  const mobile = viewport.mobile === true;
-  return {
-    width: viewport.width,
-    height: viewport.height,
-    deviceScaleFactor: deviceScaleFactor || (mobile ? MOBILE_PIXEL_RATIO : 0),
-    mobile
-  };
-}
-var log24, MOBILE_PIXEL_RATIO;
-var init_emulation = __esm({
-  "src/runtime/page/emulation.ts"() {
-    "use strict";
-    init_elementGeometry();
-    init_userAgent();
-    init_logging();
-    init_errors();
-    log24 = createLogger("session");
-    MOBILE_PIXEL_RATIO = 3;
-  }
-});
-
 // src/commands/dom/helpers/screenshot.ts
-async function waitForPostScrollStability() {
-  const deadline = Date.now() + POST_SCROLL_MAX_WAIT_MS;
-  await callBdgScript("Runtime.evaluate", {
-    expression: `
-      (() => {
-        window.__bdg_scrollStability = {
-          lastNetworkActivity: Date.now(),
-          lastDomMutation: Date.now(),
-          activeRequests: 0
-        };
-
-        const state = window.__bdg_scrollStability;
-
-        if (window.PerformanceObserver) {
-          const perfObserver = new PerformanceObserver((list) => {
-            for (const entry of list.getEntries()) {
-              if (entry.entryType === 'resource') {
-                state.lastNetworkActivity = Date.now();
-              }
-            }
-          });
-          try {
-            perfObserver.observe({ entryTypes: ['resource'] });
-            state.perfObserver = perfObserver;
-          } catch (e) {}
-        }
-
-        const mutationObserver = new MutationObserver(() => {
-          state.lastDomMutation = Date.now();
-        });
-        mutationObserver.observe(document.body || document.documentElement, {
-          childList: true,
-          subtree: true,
-          attributes: true
-        });
-        state.mutationObserver = mutationObserver;
-      })()
-    `,
-    returnByValue: true
-  });
-  try {
-    while (Date.now() < deadline) {
-      const checkResult = await callBdgScript("Runtime.evaluate", {
-        expression: `
-          (() => {
-            const state = window.__bdg_scrollStability;
-            if (!state) return { networkIdle: 999, domIdle: 999 };
-            return {
-              networkIdle: Date.now() - state.lastNetworkActivity,
-              domIdle: Date.now() - state.lastDomMutation
-            };
-          })()
-        `,
-        returnByValue: true
-      });
-      const value = checkResult.data?.result?.result?.value;
-      const networkIdle = value?.networkIdle ?? 0;
-      const domIdle = value?.domIdle ?? 0;
-      if (networkIdle >= POST_SCROLL_NETWORK_IDLE_MS && domIdle >= POST_SCROLL_DOM_STABLE_MS) {
-        log25.debug(`Post-scroll stable: network ${networkIdle}ms, DOM ${domIdle}ms`);
-        return;
-      }
-      await new Promise((resolve4) => setTimeout(resolve4, STABILITY_CHECK_INTERVAL_MS));
-    }
-    log25.debug("Post-scroll stability timeout, proceeding anyway");
-  } finally {
-    await callBdgScript("Runtime.evaluate", {
-      expression: `
-        (() => {
-          const state = window.__bdg_scrollStability;
-          if (state) {
-            state.perfObserver?.disconnect();
-            state.mutationObserver?.disconnect();
-            delete window.__bdg_scrollStability;
-          }
-        })()
-      `,
-      returnByValue: true
-    });
-  }
-}
-async function scrollToElement(selector) {
-  const result = await callBdgScript("Runtime.evaluate", {
-    expression: `
-      (() => {
-        const el = (${DEEP_QUERY_JS})(${selectorArgsJS(selector)})[0];
-        if (!el) return { found: false };
-        const originalX = window.scrollX;
-        const originalY = window.scrollY;
-        el.scrollIntoView({ block: 'center', behavior: 'instant' });
-        return { found: true, originalX, originalY };
-      })()
-    `,
-    returnByValue: true
-  });
-  const value = result.data?.result?.result?.value;
-  if (!value?.found) {
-    const err = noNodesFoundError(selector);
-    throw new CommandError(
-      err.message,
-      { suggestion: err.suggestion },
-      EXIT_CODES.RESOURCE_NOT_FOUND
-    );
-  }
-  await waitForPostScrollStability();
-  return { x: value.originalX ?? 0, y: value.originalY ?? 0 };
-}
-async function restoreScrollPosition(position) {
-  await callBdgScript("Runtime.evaluate", {
-    expression: `window.scrollTo(${position.x}, ${position.y})`,
-    returnByValue: true
-  });
-}
-async function windowSize(viewport) {
-  const response = await callBdgScript("Runtime.evaluate", {
-    expression: "[window.innerWidth, window.innerHeight]",
-    returnByValue: true
-  });
-  const value = response.data?.result?.result?.value;
-  const [width, height] = Array.isArray(value) ? value : [];
-  return {
-    width: Math.round(width ?? viewport.clientWidth),
-    height: Math.round(height ?? viewport.clientHeight)
-  };
-}
-async function useUnitPixelRatio(devicePixelRatio, viewport) {
-  if (devicePixelRatio === 1) return () => Promise.resolve();
-  const sessionViewport = readSessionMetadata()?.viewport;
-  const size = sessionViewport ?? await windowSize(viewport);
-  await callCDP("Emulation.setDeviceMetricsOverride", viewportOverride(size, 1));
-  return restoreSessionMetrics;
-}
-async function restoreSessionMetrics() {
-  const sessionViewport = readSessionMetadata()?.viewport;
-  if (!sessionViewport) {
-    await callCDP("Emulation.clearDeviceMetricsOverride", {});
-    return;
-  }
-  await callCDP("Emulation.setDeviceMetricsOverride", viewportOverride(sessionViewport));
-  if (sessionViewport.mobile) {
-    await callCDP("Emulation.setTouchEmulationEnabled", { enabled: true, maxTouchPoints: 5 });
-  }
+function screenshotInterrupted(signal) {
+  const err = screenshotInterruptedError(signal);
+  return new CommandError(err.message, { suggestion: err.suggestion }, interruptExitCode(signal));
+}
+async function requestCapture(request, interrupt) {
+  if (!interrupt) return domScreenshot(request);
+  const capture = domScreenshot(request, interrupt);
+  const response = await unlessInterrupted(capture, interrupt, screenshotInterrupted);
+  if (interrupt.aborted) throw screenshotInterrupted(interruptSignal(interrupt));
+  return response;
 }
-async function getElementBounds(ref) {
-  const response = await callCDP("DOM.getBoxModel", ref);
-  const boxModel = response.data?.result;
-  if (!boxModel?.model?.border) {
-    const err = elementNotVisibleError();
-    throw new CommandError(
-      err.message,
-      { suggestion: err.suggestion },
-      EXIT_CODES.INVALID_ARGUMENTS
+async function captureScreenshot(outputPath, request, interrupt) {
+  const response = await requestCapture(request, interrupt);
+  if (response.status === "error" || !response.data) {
+    const fallback = operationFailedError(
+      "take the screenshot",
+      `Check the session: ${sessionCommand("bdg status")}`
     );
-  }
-  const border = boxModel.model.border;
-  const x = border[0] ?? 0;
-  const y = border[1] ?? 0;
-  const width = (border[2] ?? 0) - x;
-  const height = (border[5] ?? 0) - y;
-  if (width <= 0 || height <= 0) {
-    const err = elementZeroDimensionsError();
+    const suggestion = response.error === void 0 ? fallback.suggestion : response.suggestion;
     throw new CommandError(
-      err.message,
-      { suggestion: err.suggestion },
-      EXIT_CODES.INVALID_ARGUMENTS
+      response.error ?? fallback.message,
+      suggestion ? { suggestion } : {},
+      response.exitCode ?? EXIT_CODES.CDP_CONNECTION_FAILURE
     );
   }
-  return { x, y, width, height };
-}
-async function visibleAreaOrigin() {
-  const response = await callCDP("Page.getLayoutMetrics", {});
-  const metrics = response.data?.result;
-  const viewport = metrics?.cssVisualViewport;
-  return { x: viewport?.pageX ?? 0, y: viewport?.pageY ?? 0 };
+  const path8 = await writeOutputFile(outputPath, Buffer.from(response.data.image, "base64"));
+  return { path: path8, ...response.data.screenshot };
 }
-async function capturePageScreenshot(outputPath, options = {}) {
-  const format = options.format ?? "png";
-  const quality = format === "jpeg" ? options.quality ?? 90 : void 0;
-  const requestedFullPage = options.fullPage ?? true;
-  const noResize = options.noResize ?? false;
-  let originalScrollPosition;
-  if (options.scroll) {
-    originalScrollPosition = await scrollToElement(options.scroll);
-  }
-  const dprResponse = await callBdgScript("Runtime.evaluate", {
-    expression: "window.devicePixelRatio",
-    returnByValue: true
-  });
-  const devicePixelRatio = dprResponse.data?.result?.result?.value ?? 1;
-  const metricsResponse = await callCDP("Page.getLayoutMetrics", {});
-  const metricsResult = metricsResponse.data?.result;
-  const contentSize = metricsResult?.contentSize ?? { width: 0, height: 0 };
-  const viewport = metricsResult?.visualViewport ?? { clientWidth: 0, clientHeight: 0 };
-  const pageIsTooTall = !noResize && requestedFullPage && isTallPage(contentSize.width, contentSize.height);
-  const useScroll = options.scroll !== void 0;
-  const effectiveFullPage = useScroll ? false : pageIsTooTall ? false : requestedFullPage;
-  const captureWidth = effectiveFullPage ? contentSize.width : viewport.clientWidth;
-  const captureHeight = effectiveFullPage ? contentSize.height : viewport.clientHeight;
-  const resized = shouldResize(captureWidth, captureHeight, noResize);
-  const scale = resized ? calculateResizeScale(captureWidth, captureHeight) : 1;
-  const finalWidth = Math.round(captureWidth * scale);
-  const finalHeight = Math.round(captureHeight * scale);
-  const restoreMetrics = await useUnitPixelRatio(devicePixelRatio, viewport);
-  if (devicePixelRatio !== 1) {
-    if (options.scroll) {
-      await callBdgScript("Runtime.evaluate", {
-        expression: `(${DEEP_QUERY_JS})(${selectorArgsJS(options.scroll)})[0]?.scrollIntoView({ block: 'center', behavior: 'instant' })`,
-        returnByValue: true
-      });
-    }
-  }
-  const clipOrigin = effectiveFullPage ? { x: 0, y: 0 } : await visibleAreaOrigin();
-  let screenshotResult;
-  try {
-    const screenshotResponse = await callCDP("Page.captureScreenshot", {
-      format,
-      ...quality !== void 0 && { quality },
-      captureBeyondViewport: effectiveFullPage,
-      clip: {
-        x: clipOrigin.x,
-        y: clipOrigin.y,
-        width: captureWidth,
-        height: captureHeight,
-        scale
-      }
-    });
-    screenshotResult = screenshotResponse.data?.result;
-  } finally {
-    await restoreMetrics();
-  }
-  if (!screenshotResult?.data) {
-    throw new CDPConnectionError("No screenshot data returned", new Error("Empty response"));
-  }
-  const buffer = Buffer.from(screenshotResult.data, "base64");
-  const absolutePath = await writeOutputFile(outputPath, buffer);
-  const result = {
-    path: absolutePath,
-    format,
-    width: finalWidth,
-    height: finalHeight,
-    size: buffer.length,
-    fullPage: effectiveFullPage,
-    captureMode: effectiveFullPage ? "full_page" : "viewport",
-    finalTokens: calculateImageTokens(finalWidth, finalHeight)
-  };
-  if (quality !== void 0) {
-    result.quality = quality;
-  }
-  if (!effectiveFullPage) {
-    result.viewport = {
-      width: viewport.clientWidth,
-      height: viewport.clientHeight
-    };
-  }
-  if (resized) {
-    result.resized = true;
-    result.originalWidth = captureWidth;
-    result.originalHeight = captureHeight;
-    result.originalTokens = calculateImageTokens(captureWidth, captureHeight);
-  }
-  if (pageIsTooTall && !useScroll) {
-    const aspectRatio = Math.round(contentSize.height / contentSize.width * 10) / 10;
-    result.fullPageSkipped = {
-      reason: "page_too_tall",
-      originalHeight: contentSize.height,
-      aspectRatio
-    };
-    result.warning = `Full page capture skipped: page too tall (${aspectRatio}:1 aspect ratio). Only viewport captured.`;
-  }
-  if (useScroll && options.scroll) {
-    result.scrolledTo = options.scroll;
-  }
-  if (originalScrollPosition) {
-    await restoreScrollPosition(originalScrollPosition);
-  }
-  return result;
-}
-async function visibleViewport() {
-  const metrics = (await callCDP("Page.getLayoutMetrics", {})).data?.result;
-  const view = metrics?.cssVisualViewport ?? metrics?.visualViewport;
-  return { width: view?.clientWidth ?? 0, height: view?.clientHeight ?? 0 };
-}
-function insideView(area, view) {
-  return area.x >= 0 && area.y >= 0 && area.x + area.width <= view.width && area.y + area.height <= view.height;
-}
-async function measureInView(ref, padding) {
-  const view = await visibleViewport();
-  let box = await getElementBounds(ref);
-  let bounds = await captureArea(ref, box, padding);
-  const fits = bounds.width <= view.width && bounds.height <= view.height;
-  if (!fits) {
-    await keepLayoutWithoutScrollbars(view);
-    box = await getElementBounds(ref);
-    return { box, bounds: await captureArea(ref, box, padding), inView: false };
-  }
-  if (insideView(bounds, view)) return { box, bounds, inView: true };
-  const scrolledFrom = await scrollPosition();
-  const dx = bounds.x + bounds.width / 2 - view.width / 2;
-  const dy = bounds.y + bounds.height / 2 - view.height / 2;
-  await callBdgScript("Runtime.evaluate", { expression: `window.scrollBy(${dx}, ${dy})` });
-  try {
-    box = await getElementBounds(ref);
-    bounds = await captureArea(ref, box, padding);
-  } catch (error) {
-    await restoreScrollPosition(scrolledFrom);
-    throw error;
-  }
-  return { box, bounds, inView: insideView(bounds, view), scrolledFrom };
-}
-async function keepLayoutWithoutScrollbars(view) {
-  const phone = readSessionMetadata()?.viewport?.mobile;
-  await callCDP("Emulation.setScrollbarsHidden", { hidden: true });
-  await callCDP(
-    "Emulation.setDeviceMetricsOverride",
-    viewportOverride({ ...view, ...phone && { mobile: true } }, 1)
-  );
-}
-async function restoreViewport() {
-  await callCDP("Emulation.setScrollbarsHidden", { hidden: false });
-  await restoreSessionMetrics();
-}
-async function scrollPosition() {
-  const response = await callBdgScript("Runtime.evaluate", {
-    expression: "[window.scrollX, window.scrollY]",
-    returnByValue: true
-  });
-  const value = response.data?.result?.result?.value;
-  const [x, y] = Array.isArray(value) ? value : [];
-  return { x: x ?? 0, y: y ?? 0 };
-}
-async function captureArea(ref, bounds, padding) {
-  const area = await paintedArea(ref, bounds);
-  return padding > 0 ? {
-    x: area.x - padding,
-    y: area.y - padding,
-    width: area.width + 2 * padding,
-    height: area.height + 2 * padding
-  } : area;
-}
-async function paintedArea(ref, bounds) {
-  const objectGroup = `bdg-shot-${process.pid}`;
-  try {
-    const resolved = await callBdgScript("DOM.resolveNode", { ...ref, objectGroup });
-    const objectId = resolved.data?.result?.object.objectId;
-    if (!objectId) return bounds;
-    const response = await callCDP("Runtime.callFunctionOn", {
-      objectId,
-      functionDeclaration: CONTENT_OVERFLOW_JS,
-      returnByValue: true
-    });
-    const overflow = response.data?.result?.result?.value;
-    if (!overflow) return bounds;
-    const [left, top, right, bottom] = ["left", "top", "right", "bottom"].map(
-      (side) => Math.max(0, overflow[side] ?? 0)
-    );
-    if (Math.max(left, top, right, bottom) <= OVERFLOW_SLACK) return bounds;
-    return {
-      x: bounds.x - left,
-      y: bounds.y - top,
-      width: bounds.width + left + right,
-      height: bounds.height + top + bottom
-    };
-  } catch (error) {
-    log25.debug(`Could not measure overflowing content: ${String(error)}`);
-    return bounds;
-  } finally {
-    await callCDP("Runtime.releaseObjectGroup", { objectGroup }).catch(() => void 0);
-  }
-}
-async function captureElementScreenshot(outputPath, ref, options = {}) {
-  const format = options.format ?? "png";
-  const quality = format === "jpeg" ? options.quality ?? 90 : void 0;
-  const noResize = options.noResize ?? false;
-  const dprResponse = await callBdgScript("Runtime.evaluate", {
-    expression: "window.devicePixelRatio",
-    returnByValue: true
-  });
-  const devicePixelRatio = dprResponse.data?.result?.result?.value ?? 1;
-  const before = (await callCDP("Page.getLayoutMetrics", {})).data?.result;
-  const restoreMetrics = await useUnitPixelRatio(
-    devicePixelRatio,
-    before?.visualViewport ?? { clientWidth: 800, clientHeight: 600 }
-  );
-  const restore = async (wide, scrolledFrom2) => {
-    await (wide ? restoreViewport() : restoreMetrics());
-    if (scrolledFrom2) await restoreScrollPosition(scrolledFrom2);
-  };
-  let measured;
-  try {
-    measured = await measureInView(ref, options.padding ?? 0);
-  } catch (error) {
-    await restoreViewport();
-    throw error;
-  }
-  const { box, bounds, inView, scrolledFrom } = measured;
-  const originalWidth = bounds.width;
-  const originalHeight = bounds.height;
-  const resized = shouldResize(originalWidth, originalHeight, noResize);
-  const scale = resized ? calculateResizeScale(originalWidth, originalHeight) : 1;
-  const finalWidth = Math.round(originalWidth * scale);
-  const finalHeight = Math.round(originalHeight * scale);
-  const metricsResponse = await callCDP("Page.getLayoutMetrics", {});
-  const metricsResult = metricsResponse.data?.result;
-  const scroll = metricsResult?.cssLayoutViewport ?? { pageX: 0, pageY: 0 };
-  const onPage = (area) => ({
-    ...area,
-    x: area.x + scroll.pageX,
-    y: area.y + scroll.pageY
-  });
-  const clip = onPage(bounds);
-  let screenshotResult;
-  try {
-    const screenshotResponse = await callCDP("Page.captureScreenshot", {
-      format,
-      ...quality !== void 0 && { quality },
-      clip: { ...clip, scale },
-      captureBeyondViewport: !inView
-    });
-    screenshotResult = screenshotResponse.data?.result;
-  } finally {
-    await restore(!inView, scrolledFrom);
-  }
-  if (!screenshotResult?.data) {
-    throw new CDPConnectionError("No screenshot data returned", new Error("Empty response"));
-  }
-  const buffer = Buffer.from(screenshotResult.data, "base64");
-  const absolutePath = await writeOutputFile(outputPath, buffer);
-  const result = {
-    path: absolutePath,
-    format,
-    width: finalWidth,
-    height: finalHeight,
-    size: buffer.length,
-    fullPage: false,
-    finalTokens: calculateImageTokens(finalWidth, finalHeight),
-    element: {
-      bounds: roundBounds(onPage(box)),
-      ...bounds !== box && { captured: roundBounds(clip) },
-      ...options.padding && { padding: options.padding }
-    }
-  };
-  if (quality !== void 0) {
-    result.quality = quality;
-  }
-  if (resized) {
-    result.resized = true;
-    result.originalWidth = originalWidth;
-    result.originalHeight = originalHeight;
-    result.originalTokens = calculateImageTokens(originalWidth, originalHeight);
-  }
-  return result;
-}
-function roundBounds(bounds) {
-  return {
-    x: Math.round(bounds.x),
-    y: Math.round(bounds.y),
-    width: Math.round(bounds.width),
-    height: Math.round(bounds.height)
-  };
-}
-var log25, POST_SCROLL_NETWORK_IDLE_MS, POST_SCROLL_DOM_STABLE_MS, POST_SCROLL_MAX_WAIT_MS, STABILITY_CHECK_INTERVAL_MS, OVERFLOW_SCAN_LIMIT, CONTENT_OVERFLOW_JS, OVERFLOW_SLACK;
 var init_screenshot = __esm({
   "src/commands/dom/helpers/screenshot.ts"() {
     "use strict";
-    init_screenshotResize();
+    init_interrupt();
     init_outputFile();
-    init_errors5();
     init_errors3();
     init_messages();
     init_client();
-    init_targetNode();
-    init_emulation();
-    init_metadata();
-    init_logging();
+    init_sessionCommand();
     init_exitCodes();
-    log25 = createLogger("dom");
-    POST_SCROLL_NETWORK_IDLE_MS = 150;
-    POST_SCROLL_DOM_STABLE_MS = 200;
-    POST_SCROLL_MAX_WAIT_MS = 2e3;
-    STABILITY_CHECK_INTERVAL_MS = 50;
-    OVERFLOW_SCAN_LIMIT = 2e3;
-    CONTENT_OVERFLOW_JS = `function () {
-  const view = this.ownerDocument.defaultView;
-  const scroller = this.ownerDocument.scrollingElement || this.ownerDocument.documentElement;
-  const own = this.getBoundingClientRect();
-  const reach = { left: own.left, top: own.top, right: own.right, bottom: own.bottom };
-  const page = { left: -view.scrollX, top: -view.scrollY, right: scroller.scrollWidth - view.scrollX, bottom: scroller.scrollHeight - view.scrollY };
-  const clips = (style) => style.overflowX !== 'visible' || style.overflowY !== 'visible';
-  let budget = ${OVERFLOW_SCAN_LIMIT};
-  const walk = (el) => {
-    for (const child of el.children) {
-      if (--budget < 0) return;
-      const style = view.getComputedStyle(child);
-      if (style.display === 'none' || style.position === 'fixed') continue;
-      const r = child.getBoundingClientRect();
-      if (r.width > 0 && r.height > 0 && style.visibility === 'visible') {
-        reach.left = Math.min(reach.left, Math.max(r.left, page.left));
-        reach.top = Math.min(reach.top, Math.max(r.top, page.top));
-        reach.right = Math.max(reach.right, Math.min(r.right, page.right));
-        reach.bottom = Math.max(reach.bottom, Math.min(r.bottom, page.bottom));
-      }
-      if (!clips(style)) walk(child);
-    }
-  };
-  const ownStyle = view.getComputedStyle(this);
-  if (!clips(ownStyle)) {
-    walk(this);
-    const scaleX = this.offsetWidth ? own.width / this.offsetWidth : 1;
-    const scaleY = this.offsetHeight ? own.height / this.offsetHeight : 1;
-    const wider = Math.max(0, this.scrollWidth - this.clientWidth) * scaleX;
-    const taller = Math.max(0, this.scrollHeight - this.clientHeight) * scaleY;
-    if (ownStyle.direction === 'rtl') reach.left = Math.min(reach.left, own.left - wider);
-    else reach.right = Math.max(reach.right, own.right + wider);
-    reach.bottom = Math.max(reach.bottom, own.bottom + taller);
-  }
-  const ink = { left: 0, top: 0, right: 0, bottom: 0 };
-  const grow = (side, amount) => { ink[side] = Math.max(ink[side], amount); };
-  for (const layer of ownStyle.boxShadow === 'none' ? [] : ownStyle.boxShadow.split(/,(?![^(]*\\))/)) {
-    if (/\\binset\\b/.test(layer)) continue;
-    const [x = 0, y = 0, blur = 0, spread = 0] = (layer.replace(/(rgba?|hsla?|color|oklch|lab|lch)\\([^)]*\\)/g, '').match(/-?[\\d.]+px/g) || []).map(parseFloat);
-    grow('left', blur + spread - x);
-    grow('right', blur + spread + x);
-    grow('top', blur + spread - y);
-    grow('bottom', blur + spread + y);
-  }
-  if (ownStyle.outlineStyle !== 'none') {
-    const outline = parseFloat(ownStyle.outlineWidth) + parseFloat(ownStyle.outlineOffset);
-    ['left', 'top', 'right', 'bottom'].forEach((side) => grow(side, outline));
-  }
-  return {
-    left: Math.max(own.left - reach.left, ink.left),
-    top: Math.max(own.top - reach.top, ink.top),
-    right: Math.max(reach.right - own.right, ink.right),
-    bottom: Math.max(reach.bottom - own.bottom, ink.bottom)
-  };
-}`;
-    OVERFLOW_SLACK = 1;
   }
 });
 
@@ -10405,17 +10117,15 @@ var init_screenshot = __esm({
 var helpers_exports = {};
 __export(helpers_exports, {
   assertNodeAttached: () => assertNodeAttached,
-  captureElementScreenshot: () => captureElementScreenshot,
-  capturePageScreenshot: () => capturePageScreenshot,
-  documentReadyState: () => documentReadyState,
+  captureScreenshot: () => captureScreenshot,
   getDOMElements: () => getDOMElements,
   getDomContext: () => getDomContext,
-  getElementBounds: () => getElementBounds,
   noMatchesError: () => noMatchesError,
   pageDocumentId: () => pageDocumentId,
   queryDOMElements: () => queryDOMElements,
   resolveBackendNodeIds: () => resolveBackendNodeIds,
   resolveSelector: () => resolveSelector,
+  screenshotInterrupted: () => screenshotInterrupted,
   selectMatch: () => selectMatch
 });
 var init_helpers = __esm({
@@ -13537,9 +13247,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path7) {
-    if (path7 === void 0) return this._executableDir;
-    this._executableDir = path7;
+  executableDir(path8) {
+    if (path8 === void 0) return this._executableDir;
+    this._executableDir = path8;
     return this;
   }
   /**
@@ -13797,11 +13507,15 @@ var program = new Command();
 // src/commands/helpJson.ts
 init_schema();
 
+// src/runtime/page/screenshotResize.ts
+var MAX_EDGE_PX = 1568;
+var PIXELS_PER_TOKEN = 750;
+var TALL_PAGE_THRESHOLD = 3;
+
 // src/commands/optionBehaviors.ts
-init_screenshotResize();
 var TRIGGERED_REQUESTS_BEHAVIOR = "Requests (and WebSocket connections) that start after the action begins are returned as triggeredRequests (method, url, status, durationMs; pending when still running at return, loading when the response arrived but its body is still streaming; with resourceType; human output lists documents, XHR/fetch and WebSockets first (up to 10) and counts static assets on one line; absent when network telemetry is off). Attribution is by time: requests a page timer or poller starts meanwhile are listed too, whether or not the action caused them";
-var ACTION_EFFECTS_BEHAVIOR = 'The result also says what changed on the page: a navigation (Page: navigated to <url> (status), or URL changed to <url> (same document); JSON navigation { url, sameDocument, status }), and messages that appeared or changed in alert/status/aria-live elements or flash/error/toast-like classes (New text: "\u2026" (element); JSON messages [{ text, element }], at most 3, with "(+N more)" and moreMessages for the rest; after a navigation every message on the new page counts; texts of only digits and time units, such as clocks and counters, are left out, but other text that changes on its own, such as a rotating banner, can show up). Both are absent when nothing changed. Cost: one page script sent before the action without waiting for it and one read after it, a few ms; when the page does not answer (a pending navigation) bdg waits at most 200 ms for the snapshot and 250 ms per read, and the navigation is still reported from CDP events';
-var STILL_CHANGING_BEHAVIOR = 'When the page was still changing as the action returned, the status line says (page still changing), a note below it says what was pending and suggests bdg dom wait <selector>, and JSON has settled: false with pending { requests (document, fetch/XHR and script requests still running), navigation (a new page still loading), loading (a loading indicator that appeared, e.g. "div#loading"), domChanging (DOM changes kept coming in bursts over a second look 250 ms later; a single render, ticking text and style animations do not count), busy (the page did not answer within 250 ms: a long script) }; absent when the page looked settled (exit code stays 0). A result a timer renders later, with no DOM change, request or loading indicator before it, is not detected. Cost: nothing extra, except 250 ms plus one read when the DOM looked busy. Not checked with --no-wait';
+var ACTION_EFFECTS_BEHAVIOR = 'The result also says what changed on the page: a navigation (Page: navigated to <url> (status), or URL changed to <url> (same document); JSON navigation { url, sameDocument, status }), and messages that appeared or changed in alert/status/aria-live elements or flash/error/toast-like classes (New text: "\u2026" (element); JSON messages [{ text, element }], at most 3, with "(+N more)" and moreMessages for the rest; after a navigation every message on the new page counts; texts of only digits and time units, such as clocks and counters, are left out, but other text that changes on its own, such as a rotating banner, can show up). Both are absent when nothing changed. Downloads that began meanwhile are listed (Download: <name> \u2192 <path> (<state>, <size>); JSON downloads [{ url, suggestedFilename, path, state: inProgress|completed|canceled, bytes }]); a Chrome bdg launched saves them into <session dir>/downloads (never ~/Downloads), named as suggested with (1), (2)\u2026 when taken, and one still running when the action returns is inProgress and appears at its path once complete; downloads of tabs the page opens (target=_blank, window.open) count too; when that directory cannot be created they are refused (canceled, with reason) instead of going to ~/Downloads, and if Chrome refuses the download behavior bdg status warns that downloads are not redirected; ones that begin after the action returned are listed by bdg status and bdg peek (Downloads: N (last: \u2026)); files stay after stop and cleanup; with --chrome-ws-url (the exception: not a browser bdg owns) downloads go to the download folder of that Chrome (usually ~/Downloads), only downloads of the session page are tracked (not those of tabs or popups it opens), and bdg sets behavior default with events, which replaces one another CDP client set and which Chrome drops when the session connection closes. Cost: one page script sent before the action without waiting for it and one read after it, a few ms; when the page does not answer (a pending navigation) bdg waits at most 200 ms for the snapshot and 250 ms per read, and the navigation is still reported from CDP events';
+var STILL_CHANGING_BEHAVIOR = 'When the page was still changing as the action returned, the status line says (page still changing), a note below it says what was pending and suggests bdg dom wait <selector>, and JSON has settled: false with pending { requests (document, fetch/XHR and script requests still running), navigation (a new page still loading), loading (a loading indicator that appeared, e.g. "div#loading"), domChanging (DOM changes came in bursts and, at a second look 250 ms later, again, with no quiet gap over 150 ms; time the page could not run its tasks, a long task or timers a starved renderer runs late, is not quiet, and a single burst more than 150 ms old with at most 75 ms of quiet time since also gets the second look (only that 250 ms; domChanging still needs a fresh change at it); a single render, ticking text and style animations do not count, and changes more than about 150 ms apart while the page could run look settled), busy (the page did not answer within 250 ms and ran a long task since the action began, or did not answer a check within 250 ms more: a long script; a page that answered late without a long task, a starved renderer, gets its answer waited for instead; a renderer descheduled in the middle of a task can still record a long task and is then busy; the check runs at most once per action, adding at most 250 ms, so an endless script is reported busy about 500 ms after the action) }; absent when the page looked settled (exit code stays 0). A result a timer renders later, with no DOM change, request or loading indicator before it, is not detected. Cost: nothing extra, except 250 ms plus one read when the DOM looked busy. Not checked with --no-wait';
 var SHOWN_BEHAVIOR = `Elements the action showed are listed (Shown: <element> "<text>"; JSON shown [{ text, element }], at most 3, outermost first): elements with visible text added inside the target's form, search box, dialog or combobox (else its grandparent, or its parent when that is the body), and popups and messages added anywhere (tooltip, menu, listbox, dialog, alert, status roles, popover, aria-live, message-like classes); widgets elsewhere on the page and re-rendered elements whose text was there before do not count`;
 var NO_WAIT_TRIGGERED_REQUESTS = "Returns immediately without waiting for network; triggeredRequests lists only requests bdg saw start before returning (often none yet; check bdg network list later)";
 var FOLLOW_BEHAVIOR = "Stops with exit 83 when the session it follows ends, 130 on Ctrl-C, 143 on SIGTERM; with --json prints one compact object per line (NDJSON). Other failures (a busy page, a timeout) are retried: reported once in text, as one error line per refresh in JSON";
@@ -13882,9 +13596,9 @@ var OPTION_BEHAVIORS = {
     automaticBehavior: "The value is matched as: a 0-based index (bdg dom frames order: document order of the <iframe> elements, nested ones depth-first, main page not counted), else an exact name/id attribute, else a case-insensitive part of the name, id or URL. Several matches fail with 81 listing them; none fails with 83 listing all frames. Frames are looked up on every call (a reloaded iframe is found again). An index that names another frame than in the last bdg dom frames listing (iframes added, removed or moved, or the page navigated) fails with 87 STALE_CACHE: re-run bdg dom frames or pick the frame by name."
   },
   "eval:--full": {
-    default: 'Human output prints the first 20000 characters of the value followed by "\u2026 N more chars (use --full)"; in JSON a string result is cut to 20000 characters with truncatedFrom (the original length). Objects and arrays in JSON are not cut',
-    whenEnabled: "Prints the whole value, byte for byte",
-    tokenImpact: "dom eval document.documentElement.outerHTML on Wikipedia is about 3.6 MB with --full; select what you need in the expression instead"
+    default: 'Human output prints the first 20000 characters of the value followed by "\u2026 N more chars (use --full)". In JSON a string result is cut to 20000 characters with truncatedFrom (the original length); an array result lists its first 100 elements with count (all of them) and omitted; an object or array whose JSON is still over 20000 characters becomes the first 20000 characters of its JSON text (a string; arrays keep count) with truncatedFrom (the length of the JSON text of the copy, which holds at most 1000 entries per list or object): a string result with truncatedFrom while type is object is such a JSON-text start',
+    whenEnabled: "Prints the whole value, byte for byte; objects and arrays are copied with every entry (without --full at most 1000 per list or object)",
+    tokenImpact: 'dom eval document.documentElement.outerHTML on Wikipedia is about 3.6 MB with --full; on a page with 20000 elements, [...document.querySelectorAll("*")].map(e => e.outerHTML) --json is 3 MB with --full and 23 KB without; select what you need in the expression instead'
   },
   "console:--full": {
     default: 'Message texts are cut: human output (summary, --list, --follow) at 200 characters followed by "\u2026 N more chars (use --full)"; JSON text at 10000 characters with truncatedFrom (the original length)',
@@ -14111,6 +13825,11 @@ var OPTION_BEHAVIORS = {
     whenEnabled: "Streams requests as they finish",
     automaticBehavior: FOLLOW_BEHAVIOR
   },
+  "har:--include-sensitive": {
+    default: `The HAR is sanitized: values become "[redacted]" for Authorization, Proxy-Authorization, Authentication, Cookie and Set-Cookie headers, X-*key/token/secret/auth headers and headers with an api-key/apikey/token/secret/jwt/subscription-key/session(-id) segment (www-authenticate is kept); every cookie value; query and fragment parameters named like credentials (plus code, sig, key) in the request URL, queryString, redirectURL and Location/Referer headers ("%5Bredacted%5D" in URLs); and password/token/secret/key/session/signature/bearer/cookie/csrf/refresh/auth/sid/pin/ssn/card-number fields of JSON (primitives at any depth under such a name), form-urlencoded (also sniffed when the Content-Type says otherwise, user[password] names too) and multipart request and response bodies (an access_token/refresh_token/id_token login response too) and of WebSocket messages, also in truncated JSON, JSON encoded in string values (3 levels), socket.io and SockJS packets, server-sent events, NDJSON, base64 bodies with no, a generic, JSON, form or event-stream type and binary WebSocket messages that are UTF-8 text; any whole JWT (eyJ\u2026) in a JSON string, form or URL value, multipart part or text body (only the JWT is replaced). camelCase names count as words (userPin). JSON is edited in place, not re-serialized: everything but the replaced values (64-bit numbers, formatting, duplicate keys, a BOM or )]}' prefix) stays byte for byte. Header, cookie and parameter names, cookie attributes, headersSize, bodySize and content.size stay; log.comment and JSON sanitized: true say so`,
+    whenEnabled: "Writes every captured value (JSON sanitized: false); human output warns that the file holds credentials",
+    automaticBehavior: 'Matching is by name, so it over-redacts: harmless values under credential-looking names (tokenCount: 5, sessionLength, refreshInterval, cookieConsent) are replaced too, and credentials under other names are kept. Only JSON syntax is understood: single-quoted strings, unquoted keys, JSONP, STOMP passcode: header lines and bare values with spaces ({"token":abc def}, a non-JWT token after Bearer in text) are not (fully) redacted. A body the sanitizer fails on is replaced whole by [redacted]. Unlike Chrome DevTools, which drops these headers and empties cookies, names are kept so the HAR still shows a request was authenticated. Kept as captured: other binary (base64) bodies, binary WebSocket messages that are not UTF-8, and text that is not JSON or a form (apart from JWTs); a WebSocket message cut at 100 KB has _truncatedFrom. HAR files are written readable by their owner only (0600). network headers and network getCookies always show real values'
+  },
   "peek:--verbose": {
     default: "Compact output (truncated URLs, no resource types)",
     whenEnabled: "Verbose output with full URLs and resource types"
@@ -14141,8 +13860,8 @@ var OPTION_BEHAVIORS = {
     whenEnabled: "Alias for --force, kept for compatibility"
   },
   "cleanup:--purge": {
-    default: "A named session's directory (Chrome profile, ~60 MB; logs; port.txt) is kept for its next start",
-    whenEnabled: "After cleaning up, deletes the directory of the session named by --session (exit 81 without --session); a running session is refused unless --force is given, and the directory is kept (exit 90) if the daemon still answers, cleanup reported a problem, or its Chrome has not exited"
+    default: "A named session's directory (Chrome profile, ~60 MB; logs; port.txt; downloads/) is kept for its next start",
+    whenEnabled: "After cleaning up, deletes the directory of the session named by --session, downloaded files included (exit 81 without --session); a running session is refused unless --force is given, and the directory is kept (exit 90) if the daemon still answers, cleanup reported a problem, or its Chrome has not exited"
   },
   "bdg:--viewport": {
     default: "A launched Chrome opens a 1920x1080 window (the viewport is smaller by the scrollbar, and in a visible window by the browser UI); an attached Chrome keeps its window",
@@ -14162,12 +13881,22 @@ var OPTION_BEHAVIORS = {
   "bdg:--chrome-ws-url": {
     default: "bdg launches its own Chrome (closed on stop)",
     whenEnabled: "Attaches to a running Chrome instead; it keeps running after stop. --port, -u and --[no-]headless cannot be combined with it (exit 81)",
-    automaticBehavior: "A port (9222), host:port or http://host:port is turned into the browser WebSocket URL via /json/version; a browser URL uses the first open tab. Refused with exit 90 when another running bdg session launched that Chrome or drives that tab (sessions of this BDG_SESSION_DIR, and of others that claimed a port)"
+    automaticBehavior: "A port (9222), host:port or http://host:port is turned into the browser WebSocket URL via /json/version; a browser URL uses the first open tab. Refused with exit 90 when another running bdg session launched that Chrome or drives that tab (sessions of this BDG_SESSION_DIR, and of others that claimed a port). Downloads are not redirected: they go to the download folder of that Chrome (usually ~/Downloads), and only downloads of the session page are reported (not those of tabs or popups it opens)"
   },
   "stop:--kill-chrome": {
     default: "Chrome launched by bdg is always closed on stop; an attached Chrome (--chrome-ws-url) is left running",
     whenEnabled: "No additional effect; kept for compatibility"
   },
+  "cdp:--send-anyway": {
+    default: "A Domain.method 1 edit from a bundled method or domain (2 for names over 5 letters, case ignored) is taken for a typo: exit 81 with Did you mean",
+    whenEnabled: "Sends such a name to Chrome as typed (for a method newer than the bundled protocol, e.g. next to a bundled sibling like getWindowBounds/setWindowBounds), with the not-in-bundled-protocol warning",
+    automaticBehavior: "Blocked methods (Page.captureScreenshot, Page.close, Browser.close), type names and names that are not Domain.method are still refused; a well-formed name far from every bundled one is sent without the flag"
+  },
+  "cdp:--describe": {
+    default: "Without --describe, a Domain.method is called (one missing from the bundled protocol is sent as typed, with a warning: only bundled methods are matched case-insensitively)",
+    whenEnabled: "Describes a domain, a method (parameters with ? for optional, returns, example) or a protocol type (Domain.Type: enum values or object properties)",
+    automaticBehavior: "Parameters referring to an enum type list its values inline (JSON enum, ref, refType); a redirected method (DOM.highlightNode) also shows the method implementing it and its parameters, which Chrome checks (JSON redirect, resolved: true); a redirect to a method the protocol lacks (Page.deleteCookie \u2192 Network.deleteCookie) is shown as unresolved (resolved: false). Example values work as typed: width 1280, height 800, x/y 100, deviceScaleFactor/scale 1, timeout 5000, url https://example.com, other numbers 1 (never 0, which often means off)"
+  },
   "status:--verbose": {
     default: "Basic session status (daemon running, session active, URL)",
     whenEnabled: "Includes Chrome diagnostics and CDP connection details"
@@ -14231,25 +13960,25 @@ var loggingBufferColumns = 25;
 var level_;
 var Log = class _Log {
   static _logToStdErr(title, argsArray) {
-    const log34 = _Log.loggerfn(title);
-    log34(...argsArray);
+    const log33 = _Log.loggerfn(title);
+    log33(...argsArray);
   }
   /**
    * @param {string} title
    */
   static loggerfn(title) {
     title = `LH:${title}`;
-    let log34 = loggersByTitle[title];
-    if (!log34) {
-      log34 = (0, import_debug.default)(title);
-      loggersByTitle[title] = log34;
+    let log33 = loggersByTitle[title];
+    if (!log33) {
+      log33 = (0, import_debug.default)(title);
+      loggersByTitle[title] = log33;
       if (title.endsWith("error")) {
-        log34.color = colors.red;
+        log33.color = colors.red;
       } else if (title.endsWith("warn")) {
-        log34.color = colors.yellow;
+        log33.color = colors.yellow;
       }
     }
-    return log34;
+    return log33;
   }
   /**
    * @param {string} level
@@ -14825,14 +14554,61 @@ function isDaemonSocketGone(socketPath = getSessionFilePath("DAEMON_SOCKET"), ti
   });
 }
 
+// src/session/metadata.ts
+init_logging();
+init_sessionCommand();
+init_atomicFile();
+init_errors();
+init_paths();
+import * as fs8 from "fs";
+var log6 = createLogger("session");
+function handleCorruptedMetadata(metaPath, error, options) {
+  if (options?.warnOnCorruption) {
+    log6.info(`Session metadata corrupted (cannot read details): ${getErrorMessage(error)}`);
+    log6.info(`Troubleshooting: Run "${sessionCommand("bdg cleanup")}" to remove corrupted files`);
+  }
+  if (options?.selfHealOnCorruption) {
+    try {
+      fs8.rmSync(metaPath, { force: true });
+      log6.info("Removed corrupted session metadata file");
+    } catch (deleteError) {
+      log6.debug(`Failed to remove corrupted metadata: ${getErrorMessage(deleteError)}`);
+    }
+  }
+}
+function readSessionMetadata(options) {
+  const metaPath = getSessionFilePath("METADATA");
+  if (!fs8.existsSync(metaPath)) {
+    return null;
+  }
+  try {
+    const content = fs8.readFileSync(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    handleCorruptedMetadata(metaPath, error, options);
+    return null;
+  }
+}
+
 // src/session/cleanup/staleSession.ts
-init_metadata();
 init_paths();
 init_logging();
 
 // src/utils/async.ts
-function delay2(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+function delay2(ms, signal) {
+  return new Promise((resolve4) => {
+    if (signal?.aborted) {
+      resolve4();
+      return;
+    }
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve4();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
 }
 async function waitUntil(condition, timeoutMs, pollMs = 25) {
   const deadline = Date.now() + timeoutMs;
@@ -14846,12 +14622,12 @@ async function waitUntil(condition, timeoutMs, pollMs = 25) {
 // src/utils/file.ts
 init_logging();
 import * as fs9 from "fs";
-function safeRemoveFile(path7, context, log34) {
+function safeRemoveFile(path8, context, log33) {
   try {
-    fs9.rmSync(path7, { force: true });
+    fs9.rmSync(path8, { force: true });
     return true;
   } catch (error) {
-    logDebugError(log34, `remove ${context}`, error);
+    logDebugError(log33, `remove ${context}`, error);
     return false;
   }
 }
@@ -15342,7 +15118,7 @@ function convertCompactCommand(command) {
   return {
     name: command.name(),
     ...aliases.length > 0 && { aliases },
-    description: command.description().split("\n")[0] ?? "",
+    description: command.summary() || (command.description().split("\n")[0] ?? ""),
     ...args && { arguments: args },
     ...options.length > 0 && {
       options: Object.fromEntries(options.map((option) => [option.flags, option.description]))
@@ -15439,14 +15215,14 @@ init_errors3();
 init_messages();
 init_exitCodes();
 init_suggestions();
-var COMMANDER_HINT = /\n?\(Did you mean (.+)\?\)\s*$/;
+var COMMANDER_HINT = /\n?\(Did you mean (?:one of )?(.+)\?\)\s*$/;
 function helpTopicPath(args) {
   const firstOption = args.findIndex((arg) => arg.startsWith("-"));
   return firstOption === -1 ? args : args.slice(0, firstOption);
 }
 function assertKnownHelpTopic(program2, topic) {
   let command = program2;
-  const path7 = [];
+  const path8 = [];
   for (const word of topic) {
     if (command.commands.length === 0 || word === "help") return;
     const sub = command.commands.find((c) => c.name() === word || c.aliases().includes(word));
@@ -15456,8 +15232,8 @@ function assertKnownHelpTopic(program2, topic) {
         command.commands.map((c) => c.name())
       );
       const err = unknownHelpTopicError(
-        [...path7, word].join(" "),
-        closest && [...path7, closest].join(" ")
+        [...path8, word].join(" "),
+        closest && [...path8, closest].join(" ")
       );
       throw new CommandError(
         err.message,
@@ -15465,7 +15241,7 @@ function assertKnownHelpTopic(program2, topic) {
         EXIT_CODES.INVALID_ARGUMENTS
       );
     }
-    path7.push(sub.name());
+    path8.push(sub.name());
     command = sub;
   }
 }
@@ -15473,7 +15249,10 @@ function splitCommanderHint(text) {
   const message = text.replace(/^error:\s*/i, "");
   const hint = COMMANDER_HINT.exec(message);
   if (!hint) return { message };
-  return { message: message.slice(0, hint.index).trim(), suggestion: `Did you mean: ${hint[1]}?` };
+  return {
+    message: message.slice(0, hint.index).trim(),
+    suggestion: didYouMeanSuggestion((hint[1] ?? "").split(", "))
+  };
 }
 var UNKNOWN_OPTION = /unknown option '([^'=]+)/;
 function closestOption(flag, command) {
@@ -15504,7 +15283,7 @@ function usageErrorDetails(error, command, argv = process.argv) {
 
 // src/commands/start.ts
 import fs11 from "node:fs";
-import os3 from "node:os";
+import os4 from "node:os";
 
 // src/commands/shared/commonOptions.ts
 function jsonOption() {
@@ -15529,14 +15308,14 @@ init_messages();
 
 // src/utils/version.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var cachedVersion = "";
 function getVersion() {
   if (cachedVersion) {
     return cachedVersion;
   }
   try {
-    const pkgPath = join5(PACKAGE_ROOT, "package.json");
+    const pkgPath = join6(PACKAGE_ROOT, "package.json");
     const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
     cachedVersion = pkg.version ?? "0.0.0";
   } catch {
@@ -15547,8 +15326,8 @@ function getVersion() {
 var VERSION = getVersion();
 
 // src/ui/OutputBuilder.ts
-function buildSuccessResponse(data) {
-  return { version: VERSION, success: true, data };
+function buildSuccessResponse(data, warning) {
+  return { version: VERSION, success: true, data, ...warning && { warning } };
 }
 function stringifyEnvelope(envelope) {
   return process.stdout.isTTY ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope);
@@ -15659,6 +15438,9 @@ function sessionEndedError() {
     EXIT_CODES.RESOURCE_NOT_FOUND
   );
 }
+function printWarning(warning) {
+  if (warning) console.error(escapeControlChars(`Warning: ${warning}`));
+}
 async function runCommand(handler, options, formatter) {
   try {
     const result = await handler(options);
@@ -15669,6 +15451,7 @@ async function runCommand(handler, options, formatter) {
           stringifyEnvelope(
             OutputBuilder.buildJsonError(result.error ?? "Unknown error", {
               ...result.errorContext,
+              ...result.warning && { warning: result.warning },
               exitCode
             })
           )
@@ -15684,14 +15467,16 @@ async function runCommand(handler, options, formatter) {
             }
           }
         }
+        printWarning(result.warning);
       }
       process.exit(exitCode);
     }
+    if (!options.json) printWarning(result.warning);
     if (result.hint && !options.quiet) {
       console.error(escapeControlChars(result.hint));
     }
     if (options.json) {
-      console.log(stringifyEnvelope(buildSuccessResponse(result.data)));
+      console.log(stringifyEnvelope(buildSuccessResponse(result.data, result.warning)));
     } else if (formatter) {
       const formattedOutput = formatter(result.data);
       console.log(escapeControlChars(formattedOutput));
@@ -15712,10 +15497,14 @@ async function runCommand(handler, options, formatter) {
           )
         );
       } else {
+        const { warning, ...metadata } = error.metadata;
         console.error(genericError(error.message));
-        for (const value of Object.values(error.metadata)) {
-          console.error(escapeControlChars(String(value)));
+        for (const value of Object.values(metadata)) {
+          console.error(
+            escapeControlChars(typeof value === "string" ? value : JSON.stringify(value))
+          );
         }
+        printWarning(warning);
       }
       process.exit(error.exitCode);
     }
@@ -15745,6 +15534,9 @@ async function runCommand(handler, options, formatter) {
   }
 }
 
+// src/commands/shared/startHelpers.ts
+init_interrupt();
+
 // src/ui/messages/session.ts
 init_formatting();
 init_commands();
@@ -15792,6 +15584,9 @@ function lastSessionEndText(end) {
 function endedSessionText(label, end) {
   return `${label} ended ${sessionEndText(end)}`;
 }
+function untrustedSessionText(label, why) {
+  return `${label}: ${why}`;
+}
 function sessionEndText(end) {
   const why = {
     crash: "Chrome crashed or was closed",
@@ -15849,7 +15644,7 @@ var SessionDirError = class extends DaemonError {
 // src/daemon/launcher.ts
 import { spawn } from "child_process";
 import fs10 from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 init_messages();
 init_paths();
 init_logging();
@@ -15860,6 +15655,7 @@ var log8 = createLogger("launcher");
 var DAEMON_READY_TIMEOUT_MS = 5e3;
 var DAEMON_READY_POLL_MS = 20;
 async function launchDaemon() {
+  assertUsableSessionDir();
   if (await isDaemonAlive()) {
     log8.debug("Daemon already running");
     return void 0;
@@ -15870,11 +15666,10 @@ async function launchDaemon() {
       "DAEMON_SCRIPT_NOT_FOUND"
     );
   }
-  assertUsableSessionDir();
   await stopUnreachableDaemon();
-  const logPath = join6(getSessionDir(), "daemon.log");
+  const logPath = join7(getSessionDir(), "daemon.log");
   rotateLog(logPath);
-  const logFd = fs10.openSync(logPath, "a");
+  const logFd = openDaemonLog(logPath);
   log8.debug(`Starting daemon: ${DAEMON_SCRIPT_PATH}`);
   const daemon = spawn(process.execPath, [DAEMON_SCRIPT_PATH], {
     detached: true,
@@ -15887,7 +15682,13 @@ async function launchDaemon() {
   });
   daemon.unref();
   await waitForDaemonReady(() => exited);
-  return { pid: daemon.pid, hasExited: () => exited };
+  return {
+    pid: daemon.pid,
+    hasExited: () => exited,
+    stop: () => {
+      if (!exited) daemon.kill("SIGTERM");
+    }
+  };
 }
 var UNREACHABLE_DAEMON_EXIT_MS = 8e3;
 async function stopUnreachableDaemon() {
@@ -15930,6 +15731,8 @@ function assertUsableSessionDir() {
       problem.denied ? EXIT_CODES.PERMISSION_DENIED : EXIT_CODES.SESSION_FILE_ERROR
     );
   }
+  const untrusted = secureSessionDir(dir);
+  if (untrusted) fail(untrustedSessionDirError(untrusted));
   try {
     ensureSessionDir();
     fs10.accessSync(dir, fs10.constants.W_OK);
@@ -15942,6 +15745,18 @@ function assertUsableSessionDir() {
     );
   }
 }
+var DAEMON_LOG_FLAGS = fs10.constants.O_WRONLY | fs10.constants.O_APPEND | fs10.constants.O_CREAT | (fs10.constants.O_NOFOLLOW ?? 0);
+function openDaemonLog(logPath) {
+  try {
+    return fs10.openSync(logPath, DAEMON_LOG_FLAGS, 384);
+  } catch (error) {
+    const err = daemonLogNotOpenedError(
+      logPath,
+      error.code ?? getErrorMessage(error)
+    );
+    throw new SessionDirError(err.message, err.suggestion);
+  }
+}
 var MAX_LOG_BYTES = 5 * 1024 * 1024;
 function rotateLog(logPath) {
   try {
@@ -15961,7 +15776,7 @@ async function waitForDaemonReady(hasExited) {
     }
     if (hasExited() && !await isDaemonAlive()) {
       throw new DaemonStartupError(
-        `Daemon exited during startup. See ${join6(getSessionDir(), "daemon.log")}`,
+        `Daemon exited during startup. See ${join7(getSessionDir(), "daemon.log")}`,
         "DAEMON_EXITED"
       );
     }
@@ -16006,6 +15821,7 @@ var COMMANDS = {
   dom_audit: defineCommand(),
   css_search: defineCommand(),
   dom_inspect: defineCommand(),
+  dom_screenshot: defineCommand(),
   dom_wait: defineCommand()
 };
 
@@ -16088,27 +15904,58 @@ var SPAWNED_DAEMON_EXIT_WAIT_MS = 3e3;
 var DEFAULT_START_DEPS = {
   launch: launchDaemon,
   send: startSession,
+  stop: stopSession,
   exitWaitMs: SPAWNED_DAEMON_EXIT_WAIT_MS
 };
 async function startSessionViaDaemon(url, options, telemetry) {
-  process.once("SIGINT", () => reportStartOutcome(interruptedOutcome("SIGINT"), options));
-  process.once("SIGTERM", () => reportStartOutcome(interruptedOutcome("SIGTERM"), options));
-  reportStartOutcome(await attemptStart(url, options, telemetry), options);
+  const interrupt = new AbortController();
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      if (interrupt.signal.aborted) reportStartOutcome(interruptedOutcome(signal), options);
+      interrupt.abort(signal);
+    });
+  }
+  reportStartOutcome(
+    await attemptStart(url, options, telemetry, DEFAULT_START_DEPS, interrupt.signal),
+    options
+  );
 }
-async function attemptStart(url, options, telemetry, deps = DEFAULT_START_DEPS) {
+async function attemptStart(url, options, telemetry, deps = DEFAULT_START_DEPS, interrupt) {
   const spawned = [];
   const attempt = async () => {
-    const outcome2 = await requestSession(url, options, telemetry, deps);
+    const outcome2 = await requestSession(url, options, telemetry, deps, interrupt);
     if (!outcome2.ok && outcome2.spawned) spawned.push(outcome2.spawned);
     return outcome2;
   };
   let outcome = await attempt();
   const deadline = Date.now() + SHUTDOWN_WAIT_MS;
   while (isShuttingDown(outcome) && Date.now() < deadline) {
-    await delay2(SHUTDOWN_POLL_MS);
+    await delay2(SHUTDOWN_POLL_MS, interrupt);
     outcome = await attempt();
   }
-  return afterSpawnedDaemonExit(outcome, spawned, deps.exitWaitMs);
+  return settleOutcome(outcome, spawned, deps, interrupt);
+}
+async function settleOutcome(outcome, spawned, deps, interrupt) {
+  if (outcome.ok) {
+    const { spawned: daemon, ...started } = outcome;
+    return interrupt?.aborted ? cancelStartedSession(started.data, daemon, deps, interrupt) : started;
+  }
+  const failure = await afterSpawnedDaemonExit(outcome, spawned, deps.exitWaitMs);
+  return interrupt?.aborted ? withInterruptExitCode(failure, interrupt) : failure;
+}
+function cancelStartedSession(data, spawned, deps, interrupt) {
+  log11.debug("Interrupted as the session started; stopping it");
+  deps.stop().catch((error) => {
+    log11.debug(`Stopping the interrupted session failed: ${getErrorMessage(error)}`);
+  });
+  const daemon = spawned ?? {
+    pid: data.daemonPid,
+    hasExited: () => !isProcessAlive(data.daemonPid)
+  };
+  return afterSpawnedDaemonExit(cancelledOutcome(interrupt), [daemon], deps.exitWaitMs);
+}
+function withInterruptExitCode(outcome, interrupt) {
+  return outcome.ok ? outcome : { ...outcome, exitCode: interruptExitCode(interruptSignal(interrupt)) };
 }
 async function afterSpawnedDaemonExit(outcome, spawned, waitMs) {
   if (outcome.ok) return outcome;
@@ -16136,15 +15983,18 @@ async function afterSpawnedDaemonExit(outcome, spawned, waitMs) {
 }
 function interruptedOutcome(signal) {
   const message = `Start cancelled (${signal === "SIGINT" ? "interrupted" : "terminated"})`;
-  const exitCode = signal === "SIGINT" ? EXIT_CODES.INTERRUPTED : EXIT_CODES.TERMINATED;
-  return { ok: false, error: message, human: message, exitCode };
+  return { ok: false, error: message, human: message, exitCode: interruptExitCode(signal) };
+}
+function cancelledOutcome(interrupt) {
+  return interruptedOutcome(interruptSignal(interrupt));
 }
 var SHUTDOWN_WAIT_MS = 15e3;
 var SHUTDOWN_POLL_MS = 200;
 function isShuttingDown(outcome) {
   return !outcome.ok && (outcome.retryable === true || outcome.errorCode === "SESSION_SHUTTING_DOWN" /* SESSION_SHUTTING_DOWN */);
 }
-async function requestSession(url, options, telemetry, deps) {
+async function requestSession(url, options, telemetry, deps, interrupt) {
+  if (interrupt?.aborted) return cancelledOutcome(interrupt);
   let spawned;
   try {
     spawned = await deps.launch();
@@ -16162,10 +16012,16 @@ async function requestSession(url, options, telemetry, deps) {
     const exitCode = error instanceof DaemonError ? error.exitCode : EXIT_CODES.SOFTWARE_ERROR;
     return { ok: false, error: message, human: genericError(message), exitCode };
   }
-  const outcome = await sendStart(url, options, telemetry, deps.send);
-  return !outcome.ok && outcome.daemonExiting && spawned ? { ...outcome, spawned } : outcome;
+  if (interrupt?.aborted) return cancelBeforeRequest(spawned, interrupt);
+  const outcome = await sendStart(url, options, telemetry, deps.send, interrupt);
+  return spawned && (outcome.ok || outcome.daemonExiting) ? { ...outcome, spawned } : outcome;
+}
+function cancelBeforeRequest(spawned, interrupt) {
+  if (!spawned) return cancelledOutcome(interrupt);
+  spawned.stop();
+  return { ...cancelledOutcome(interrupt), daemonExiting: true, spawned };
 }
-async function sendStart(url, options, telemetry, send) {
+async function sendStart(url, options, telemetry, send, interrupt) {
   try {
     log11.debug("Connecting to daemon...");
     const response = await send(
@@ -16182,7 +16038,8 @@ async function sendStart(url, options, telemetry, send) {
         chromeFlags: options.chromeFlags,
         viewport: options.viewport,
         colorScheme: options.colorScheme
-      })
+      }),
+      interrupt
     );
     if (response.status === "error") {
       return { ...describeStartFailure(response, options), daemonExiting: true };
@@ -16198,6 +16055,7 @@ async function sendStart(url, options, telemetry, send) {
     }
     return { ok: true, data: response.data };
   } catch (error) {
+    if (interrupt?.aborted) return { ...cancelledOutcome(interrupt), daemonExiting: true };
     if (error instanceof IPCTimeoutError) {
       const timeout = timeoutError(error);
       return {
@@ -16547,9 +16405,11 @@ var CDP_HTTP_TIMEOUT_MS = 5e3;
 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;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const signal = options?.signal ? AbortSignal.any([timeout, options.signal]) : timeout;
   let response;
   try {
-    response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    response = await fetch(url, { signal });
   } catch (error) {
     logger?.debug(`Chrome version request failed: ${getErrorMessage(error)} (${url})`);
     return { kind: "unreachable" };
@@ -16568,7 +16428,7 @@ async function probeDevToolsEndpoint(port, logger, options) {
 init_suggestions();
 init_url();
 function expandHome(value) {
-  return value.startsWith("~/") ? value.replace(/^~/, os3.homedir()) : value;
+  return value.startsWith("~/") ? value.replace(/^~/, os4.homedir()) : value;
 }
 function extractUserDataDirFromFlags(flags) {
   const rest = [];
@@ -16864,6 +16724,50 @@ function assertValidChromeWsUrl(url) {
 init_errors3();
 init_messages();
 
+// src/cdp/methodTarget.ts
+init_protocol();
+init_levenshtein();
+init_suggestions();
+var METHOD_NAME = /^[A-Za-z][A-Za-z0-9]*\.[A-Za-z][A-Za-z0-9]*$/;
+function typoLimit(name) {
+  return name.length <= 5 ? 1 : 2;
+}
+function closeNames(input, candidates) {
+  const lower = input.toLowerCase();
+  return candidates.map((name) => ({ name, distance: levenshteinDistance(lower, name.toLowerCase()) })).filter(({ distance }) => distance > 0 && distance <= typoLimit(input)).sort((a, b) => a.distance - b.distance).map(({ name }) => name);
+}
+function closeMethods(domainName, methodName) {
+  const commands = findDomain(domainName)?.commands ?? [];
+  const exact = commands.find((c) => c.name.toLowerCase() === methodName.toLowerCase());
+  const names = exact ? [exact.name] : closeNames(
+    methodName,
+    commands.map((c) => c.name)
+  );
+  return names.map((name) => `${domainName}.${name}`);
+}
+function resolveUnknownDomain(domainName, methodName) {
+  const domains = closeNames(
+    domainName,
+    loadProtocol().domains.map((d) => d.domain)
+  );
+  const method = `${domainName}.${methodName}`;
+  if (domains.length === 0) return { kind: "unlisted", method };
+  return { kind: "typo", method, suggestions: domains.flatMap((d) => closeMethods(d, methodName)) };
+}
+function resolveMethodTarget(input) {
+  if (!METHOD_NAME.test(input)) return { kind: "malformed" };
+  const known = normalizeMethod(input);
+  if (known) return { kind: "known", method: known };
+  const [domainName = "", methodName = ""] = input.split(".");
+  const domain = findDomain(domainName);
+  if (!domain) return resolveUnknownDomain(domainName, methodName);
+  const type = findType(domain.domain, methodName);
+  if (type) return { kind: "type", name: `${domain.domain}.${type.id}` };
+  const method = `${domain.domain}.${methodName}`;
+  const suggestions = closeMethods(domain.domain, methodName);
+  return suggestions.length > 0 ? { kind: "typo", method, suggestions } : { kind: "unlisted", method };
+}
+
 // src/commands/cdp.ts
 init_protocol();
 init_schema();
@@ -16871,8 +16775,10 @@ init_errors3();
 init_messages();
 init_client();
 
+// src/connection/errors.ts
+init_exitCodes();
+
 // src/runtime/dom/evalHelpers.ts
-init_errors5();
 init_errors3();
 init_messages();
 
@@ -16906,11 +16812,7 @@ var WEBSOCKET_CONFIG = {
   noPongClosure: 1001
 };
 
-// src/connection/cdp.ts
-init_errors5();
-
 // src/daemon/session/cdpSetup.ts
-init_errors5();
 init_constants();
 init_errors3();
 init_messages();
@@ -17104,6 +17006,7 @@ function describeException(details) {
 
 // src/ui/formatters/cdp.ts
 init_formatting();
+init_commands();
 function firstSentence(description) {
   const [line = ""] = (description ?? "").split("\n");
   const end = line.indexOf(". ");
@@ -17122,6 +17025,16 @@ function columns(rows) {
 function typeText(field) {
   return field.items ? `${field.type}<${field.items}>` : field.type;
 }
+var MAX_ENUM_VALUES = 8;
+function expansionText(field) {
+  const values = field.enum;
+  if (!values || values.length === 0) {
+    return field.refType && field.refType !== "object" ? ` (${field.refType})` : "";
+  }
+  const shown = values.slice(0, MAX_ENUM_VALUES);
+  const more = values.length - shown.length;
+  return ` (${[...shown, ...more > 0 ? [`\u2026 ${more} more`] : []].join("|")})`;
+}
 function formatCdpSearch(data) {
   if (data.count === 0) {
     return joinLines(`No CDP method matches "${data.query}"`, "List the domains: bdg cdp --list");
@@ -17158,13 +17071,37 @@ function fieldSection(title, fields) {
     `${title}:`,
     ...columns(
       fields.map((f) => [
-        `${f.name}${f.optional ? "?" : ""}: ${typeText(f)}`,
-        (f.description ?? "").replace(/\s*\n\s*/g, " ")
+        `${f.name}${f.optional ? "?" : ""}: ${typeText(f)}${expansionText(f)}`,
+        `${(f.description ?? "").replace(/\s*\n\s*/g, " ")}${tags(f)}`
       ])
     )
   ];
 }
+function parameterFields(parameters) {
+  return parameters.map((p) => ({ ...p, optional: !p.required }));
+}
+function typeHint(parameters) {
+  const ref = parameters.find((p) => p.refType === "object")?.ref;
+  return ref && `Describe a type: bdg cdp ${ref} --describe`;
+}
+function redirectSection(redirect) {
+  if (!redirect) return [];
+  if (!redirect.resolved) return [cdpUnresolvedRedirectLine(redirect.method)];
+  const title = cdpRedirectTitle(redirect.method);
+  return redirect.parameters.length === 0 ? [title] : fieldSection(`${title}, with these parameters`, parameterFields(redirect.parameters));
+}
+function formatCdpType(data) {
+  const properties = data.properties ?? [];
+  return joinLines(
+    `${data.name}: ${typeText({ name: data.id, type: data.baseType, items: data.items })}${tags(data)}`,
+    data.description,
+    data.enum && `Values: ${data.enum.join(", ")}`,
+    ...fieldSection("Properties", parameterFields(properties)),
+    typeHint(properties)
+  );
+}
 function formatCdpDescription(data) {
+  if (data.type === "type") return formatCdpType(data);
   if (data.type === "domain") {
     return joinLines(
       `${data.domain}: ${pluralize(data.commands, "method")}, ${pluralize(data.events, "event")}${tags(data)}`,
@@ -17173,15 +17110,15 @@ function formatCdpDescription(data) {
       data.nextStep
     );
   }
+  const redirected = data.redirect?.parameters ?? [];
   return joinLines(
     `${data.name}${tags(data)}`,
     data.description,
-    ...fieldSection(
-      "Parameters",
-      data.parameters.map((p) => ({ ...p, optional: !p.required }))
-    ),
+    ...fieldSection("Parameters", parameterFields(data.parameters)),
+    ...redirectSection(data.redirect),
     ...fieldSection("Returns", data.returns),
     data.note && `Note: ${data.note}`,
+    typeHint([...data.parameters, ...redirected]),
     data.example && `Example: ${data.example.command}`
   );
 }
@@ -17192,6 +17129,9 @@ function formatCdpResult(data) {
   return isEmptyCdpResult(data.result) ? `${data.method}: done (no result data)` : JSON.stringify(data.result, null, 2);
 }
 
+// src/commands/cdp.ts
+init_commands();
+
 // src/ui/messages/hints.ts
 init_formatting();
 init_sessionCommand();
@@ -17244,14 +17184,19 @@ function getMethodHint(methodName, result) {
   return void 0;
 }
 function registerCdpCommand(program2) {
-  program2.command("cdp").description(
-    "CDP protocol introspection and execution\n  Discovery: --list, --search, --describe\n  Execution: case-insensitive (network.getcookies works)"
+  program2.command("cdp").summary("CDP protocol introspection and execution").description(
+    "CDP protocol introspection and execution\n  Discovery: --list, --search, --describe\n" + CDP_EXECUTION_HELP
   ).argument("[method]", "CDP method name (e.g., Network.getCookies, network.getcookies)").addOption(new Option("--params <json>", "Method parameters as JSON")).addOption(
     new Option("--list", "List all domains or methods in a domain").conflicts([
       "describe",
       "params"
     ])
   ).addOption(new Option("--describe", "Show method signature and parameters").conflicts("params")).addOption(
+    new Option(
+      "--send-anyway",
+      "Send a Domain.method that looks like a typo of a bundled one as typed"
+    ).conflicts(["list", "describe", "search"])
+  ).addOption(
     new Option("--search <query>", "Search methods by keyword").conflicts([
       "list",
       "describe",
@@ -17275,11 +17220,7 @@ async function runCdpCommand(method, options) {
     return runCommand(async () => handleDescribeMethod(method), options, formatCdpDescription);
   }
   if (method) {
-    return runCommand(
-      async () => handleExecuteMethod(method, options.params),
-      options,
-      formatCdpResult
-    );
+    return runCommand(async () => handleExecuteMethod(method, options), options, formatCdpResult);
   }
   return runCommand(async () => {
     const err = missingArgumentError(CDP_USAGE);
@@ -17433,94 +17374,97 @@ function handleListDomainMethods(domainName) {
     }
   };
 }
-function handleDescribeMethod(methodName) {
-  const [domainName, method] = methodName.includes(".") ? methodName.split(".") : [methodName, void 0];
-  if (!method) {
-    const summary = getDomainSummary(domainName);
-    if (!summary) {
-      const similar = findSimilarMethods(methodName);
-      const suggestions = ["Use: bdg cdp --list (to see all domains)"];
-      if (similar.length > 0) {
-        suggestions.push("");
-        suggestions.push("Did you mean:");
-        similar.forEach((name) => suggestions.push(`  - ${name}`));
-      }
-      return {
-        success: false,
-        error: `Domain or method '${methodName}' not found`,
-        exitCode: EXIT_CODES.INVALID_ARGUMENTS,
-        errorContext: {
-          suggestion: suggestions.join("\n")
-        }
-      };
-    }
-    const domainNote = DOMAIN_NOTES[summary.name];
-    return {
-      success: true,
-      data: {
-        type: "domain",
-        domain: summary.name,
-        description: summary.description,
-        commands: summary.commandCount,
-        events: summary.eventCount,
-        experimental: summary.experimental,
-        deprecated: summary.deprecated,
-        note: domainNote,
-        nextStep: `Use: bdg cdp ${summary.name} --list (to see all methods)`
-      }
-    };
-  }
-  const schema = getMethodSchema(domainName, method);
-  if (!schema) {
-    const similar = findSimilarMethods(methodName, domainName);
-    const suggestions = [`Use: bdg cdp ${domainName} --list (to see all ${domainName} methods)`];
-    if (similar.length > 0) {
-      suggestions.push("");
-      suggestions.push("Did you mean:");
-      similar.forEach((name) => suggestions.push(`  - ${name}`));
-    }
+function handleDescribeMethod(name) {
+  const [domainName = "", member] = name.includes(".") ? name.split(".") : [name, void 0];
+  if (!member) return describeDomain(name);
+  const schema = getMethodSchema(domainName, member);
+  if (schema) return { success: true, data: describeMethod(schema) };
+  const type = getTypeSchema(domainName, member);
+  if (type) return { success: true, data: { type: "type", ...type } };
+  const target = resolveMethodTarget(name);
+  const err = target.kind === "unlisted" ? cdpMethodNotInBundledProtocolError(target.method, getBundledProtocolVersion()) : cdpMethodNotFoundError(
+    name,
+    findSimilarMethods(name, domainName),
+    `Use: bdg cdp ${domainName} --list (to see all ${domainName} methods)`
+  );
+  return {
+    success: false,
+    error: err.message,
+    exitCode: EXIT_CODES.INVALID_ARGUMENTS,
+    errorContext: { suggestion: err.suggestion }
+  };
+}
+function describeDomain(domainName) {
+  const summary = getDomainSummary(domainName);
+  if (!summary) {
+    const err = cdpMethodNotFoundError(
+      domainName,
+      findSimilarMethods(domainName),
+      "Use: bdg cdp --list (to see all domains)"
+    );
     return {
       success: false,
-      error: `Method '${methodName}' not found`,
+      error: `Domain or method '${domainName}' not found`,
       exitCode: EXIT_CODES.INVALID_ARGUMENTS,
-      errorContext: {
-        suggestion: suggestions.join("\n")
-      }
+      errorContext: { suggestion: err.suggestion }
     };
   }
-  const methodNote = METHOD_NOTES[schema.name] ?? DOMAIN_NOTES[schema.domain];
-  const alternative = blockedAlternative(schema.name);
   return {
     success: true,
     data: {
-      type: "method",
-      name: schema.name,
-      domain: schema.domain,
-      method: schema.method,
-      description: schema.description,
-      experimental: schema.experimental,
-      deprecated: schema.deprecated,
-      note: methodNote,
-      parameters: schema.parameters.map((p) => ({
-        name: p.name,
-        type: p.type,
-        required: p.required,
-        description: p.description,
-        enum: p.enum,
-        items: p.items,
-        deprecated: p.deprecated
-      })),
-      returns: schema.returns.map((r) => ({
-        name: r.name,
-        type: r.type,
-        optional: r.optional,
-        description: r.description,
-        items: r.items
-      })),
-      example: alternative ? { command: alternative } : schema.example
+      type: "domain",
+      domain: summary.name,
+      description: summary.description,
+      commands: summary.commandCount,
+      events: summary.eventCount,
+      experimental: summary.experimental,
+      deprecated: summary.deprecated,
+      note: DOMAIN_NOTES[summary.name],
+      nextStep: `Use: bdg cdp ${summary.name} --list (to see all methods)`
     }
   };
 }
+function describeParameter(p) {
+  return {
+    name: p.name,
+    type: p.type,
+    required: p.required,
+    description: p.description,
+    enum: p.enum,
+    ref: p.ref,
+    refType: p.refType,
+    items: p.items,
+    experimental: p.experimental,
+    deprecated: p.deprecated
+  };
+}
+function describeMethod(schema) {
+  const alternative = blockedAlternative(schema.name);
+  return {
+    type: "method",
+    name: schema.name,
+    domain: schema.domain,
+    method: schema.method,
+    description: schema.description,
+    experimental: schema.experimental,
+    deprecated: schema.deprecated,
+    note: METHOD_NOTES[schema.name] ?? DOMAIN_NOTES[schema.domain],
+    parameters: schema.parameters.map(describeParameter),
+    returns: schema.returns.map((r) => ({
+      name: r.name,
+      type: r.type,
+      optional: r.optional,
+      description: r.description,
+      items: r.items
+    })),
+    redirect: schema.redirect && {
+      method: schema.redirect.method,
+      resolved: schema.redirect.resolved,
+      parameters: schema.redirect.parameters.map(describeParameter)
+    },
+    example: alternative ? { command: alternative } : schema.example
+  };
+}
 var BLOCKED_CDP_METHODS = {
   "Page.captureScreenshot": {
     alternative: "bdg dom screenshot [path]",
@@ -17535,38 +17479,53 @@ var BLOCKED_CDP_METHODS = {
     reason: "Closes Chrome under the session, which then ends without saving its state"
   }
 };
-async function handleExecuteMethod(methodName, paramsJson) {
-  const normalized = normalizeMethod(methodName);
-  if (normalized && BLOCKED_CDP_METHODS[normalized]) {
-    const blocked = BLOCKED_CDP_METHODS[normalized];
-    return {
-      success: false,
-      error: `${normalized} is blocked via raw CDP: ${blocked.reason}`,
-      exitCode: EXIT_CODES.INVALID_ARGUMENTS,
-      errorContext: { suggestion: `Use: ${sessionCommand(blocked.alternative)}` }
-    };
-  }
-  if (!normalized) {
-    const similar = findSimilarMethods(methodName);
-    const suggestions = ["Use: bdg cdp --search <keyword> (to search for methods)"];
-    if (similar.length > 0) {
-      suggestions.push("");
-      suggestions.push("Did you mean:");
-      similar.forEach((name) => suggestions.push(`  - ${name}`));
+function methodToSend(methodName, options = {}) {
+  const target = resolveMethodTarget(methodName);
+  if (target.kind === "known") {
+    const blocked = BLOCKED_CDP_METHODS[target.method];
+    if (blocked) {
+      throw new CommandError(
+        `${target.method} is blocked via raw CDP: ${blocked.reason}`,
+        { suggestion: `Use: ${sessionCommand(blocked.alternative)}` },
+        EXIT_CODES.INVALID_ARGUMENTS
+      );
     }
+    return { method: target.method };
+  }
+  if (target.kind === "unlisted" || target.kind === "typo" && options.sendAnyway) {
     return {
-      success: false,
-      error: `Method '${methodName}' not found`,
-      exitCode: EXIT_CODES.INVALID_ARGUMENTS,
-      errorContext: {
-        suggestion: suggestions.join("\n")
-      }
+      method: target.method,
+      warning: cdpUnlistedMethodWarning(target.method, getBundledProtocolVersion())
     };
   }
+  const err = target.kind === "type" ? cdpTypeNotMethodError(target.name) : unknownMethodError(methodName, target);
+  throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+}
+function unknownMethodError(methodName, target) {
+  if (target.kind === "malformed") {
+    return cdpMethodNotFoundError(
+      methodName,
+      findSimilarMethods(methodName),
+      "Use: bdg cdp --search <keyword> (to search for methods)"
+    );
+  }
+  const [domainName = ""] = methodName.split(".");
+  return target.suggestions.length > 0 ? cdpMethodTypoError(
+    methodName,
+    target.suggestions.slice(0, 3),
+    "Use: bdg cdp --search <keyword> (to search for methods)"
+  ) : cdpMethodTypoError(methodName, [], domainSuggestion(domainName));
+}
+function withWarning(error, warning) {
+  if (!warning || !(error instanceof CommandError)) return error;
+  return new CommandError(error.message, { ...error.metadata, warning }, error.exitCode);
+}
+async function handleExecuteMethod(methodName, options) {
+  const { method: normalized, warning } = methodToSend(methodName, options);
   let params;
-  if (paramsJson) {
+  if (options.params) {
     try {
-      params = JSON.parse(paramsJson);
+      params = JSON.parse(options.params);
     } catch (error) {
       return {
         success: false,
@@ -17574,31 +17533,31 @@ async function handleExecuteMethod(methodName, paramsJson) {
         exitCode: EXIT_CODES.INVALID_ARGUMENTS,
         errorContext: {
           suggestion: `Use: bdg cdp ${normalized} --describe (to see parameter schema)`
-        }
+        },
+        ...warning && { warning }
       };
     }
   }
   const response = await callCDP(normalized, params);
-  validateIPCResponse(response);
-  const cdpResult = response.data?.result;
+  try {
+    validateIPCResponse(response);
+  } catch (error) {
+    throw withWarning(error, warning);
+  }
+  const ipcHint = response.data?.hint && formatHint(response.data.hint);
+  return cdpCallResult(normalized, response.data?.result, warning, ipcHint);
+}
+function cdpCallResult(method, cdpResult, warning, ipcHint) {
+  const withCallWarning = warning ? { warning } : {};
   const exception = pageExceptionResult(cdpResult);
-  if (exception) return exception;
-  const result = {
+  if (exception) return { ...exception, ...withCallWarning };
+  const hints = [ipcHint, getMethodHint(method, cdpResult)].filter(Boolean);
+  return {
     success: true,
-    data: {
-      method: normalized,
-      result: cdpResult
-    }
+    data: { method, result: cdpResult },
+    ...withCallWarning,
+    ...hints.length > 0 && { hint: hints.join("\n") }
   };
-  if (response.data?.hint) {
-    result.hint = formatHint(response.data.hint);
-  }
-  const methodHint = getMethodHint(normalized, cdpResult);
-  if (methodHint) {
-    result.hint = result.hint ? `${result.hint}
-${methodHint}` : methodHint;
-  }
-  return result;
 }
 
 // src/commands/cleanup.ts
@@ -17701,6 +17660,7 @@ function formatCleanup(data) {
   return joinLines(
     cleaned.session && sessionFilesCleanedMessage(),
     cleaned.output && sessionOutputRemovedMessage(),
+    data.downloadsKept && downloadsKeptMessage(data.downloadsKept.dir, data.downloadsKept.files),
     ...(data.warnings ?? []).map((warning) => warningMessage(warning)),
     "",
     data.message
@@ -17789,18 +17749,26 @@ async function cleanupSession(opts) {
     };
   }
   const didCleanup = Object.values(cleaned).some(Boolean) || purged !== void 0;
+  const downloadsKept = purged === void 0 ? keptDownloads() : void 0;
   return {
     success: true,
     data: {
       cleaned,
       ...purged !== void 0 && { purged },
+      ...downloadsKept && { downloadsKept },
       message: !didCleanup ? noSessionFilesMessage() : purged !== void 0 ? sessionDirectoryPurgedMessage(purged) : sessionDirectoryCleanMessage(),
       ...warnings.length > 0 && { warnings }
     }
   };
 }
+function keptDownloads() {
+  const dir = getSessionDownloadsDir();
+  if (!fs14.existsSync(dir) || !fs14.statSync(dir).isDirectory()) return void 0;
+  const files = fs14.readdirSync(dir).length;
+  return files > 0 ? { dir, files } : void 0;
+}
 function registerCleanupCommand(program2) {
-  program2.command("cleanup").description("Clean up stale session files").option("-f, --force", "Kill a running (possibly hung) session, then clean up", false).option("--remove-output", "Also remove session.json output file", false).option("--aggressive", "Alias for --force (kept for compatibility)", false).option(
+  program2.command("cleanup").description("Clean up stale session files (downloaded files are kept)").option("-f, --force", "Kill a running (possibly hung) session, then clean up", false).option("--remove-output", "Also remove session.json output file", false).option("--aggressive", "Alias for --force (kept for compatibility)", false).option(
     "--purge",
     "Also delete a named session's directory (Chrome profile, logs, port); needs --session",
     false
@@ -18717,7 +18685,11 @@ function megabytes(bytes) {
 function networkEvictedNote(counts) {
   const { requestsDropped, bodiesEvicted } = counts;
   const requests = pluralize(requestsDropped, "older network request");
-  const bodies = pluralize(bodiesEvicted, "older response body", "older response bodies");
+  const bodies = pluralize(
+    bodiesEvicted,
+    "older request/response body",
+    "older request/response bodies"
+  );
   const budget = megabytes(MAX_TOTAL_BODY_BYTES);
   if (requestsDropped > 0 && bodiesEvicted > 0) {
     return `\u26A0 ${requests} dropped, ${bodies} evicted: bdg keeps the newest ${MAX_NETWORK_REQUESTS} requests and ${budget} of bodies`;
@@ -18742,6 +18714,15 @@ function headerRepeatedNote(count) {
 function localProxyNote() {
   return "(loopback; likely a local proxy)";
 }
+function harSanitizedComment() {
+  return "Sanitized by bdg: values of auth, cookie, API key, token and session headers, cookies, credential query parameters in URLs, password/token/secret fields of JSON and form request and response bodies and WebSocket messages (also truncated JSON, JSON encoded in strings, socket.io, SockJS, server-sent events, NDJSON, and base64 bodies and binary messages that are UTF-8 text), and any JWT (also inside longer strings and form values) are [redacted] in place (by name, so some harmless values are too); everything else stays byte for byte. Not sanitized: other binary data, text that is not JSON or a form, and non-JSON syntax (single quotes, unquoted keys, JSONP, bare values with spaces); a body that could not be sanitized is [redacted] whole. Export with --include-sensitive to keep everything";
+}
+function harExportedMessage(result) {
+  const filterNote = result.filtered ? " (filtered)" : "";
+  const note = result.sanitized ? "Credentials sanitized (auth/cookie/API key/token headers, cookies, URL tokens, password and token fields of bodies and WebSocket messages are [redacted]); --include-sensitive keeps them" : "\u26A0 Includes credentials (--include-sensitive): share this file with care";
+  return `\u2713 Exported ${result.entries} requests${filterNote} to ${result.file}
+  ${note}`;
+}
 
 // src/telemetry/networkRetention.ts
 var SKIPPED_BODY_PATTERN = /^\[SKIPPED: (.*)\]$/s;
@@ -18854,10 +18835,6 @@ function addWebSocketMessages(fmt, webSocket) {
   webSocket.frames.forEach((frame) => fmt.text(formatWebSocketMessage(frame)));
 }
 var BODY_PREVIEW_LENGTH = 2e4;
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-}
 function isLoopback(ip) {
   const bare = ip.replace(/^\[|\]$/g, "").toLowerCase();
   return /^(::ffff:)?127\./.test(bare) || bare === "::1";
@@ -18933,7 +18910,11 @@ function formatNetworkDetails(request) {
   fmt.keyValueList(requestSummaryRows(request));
   fmt.blank();
   if (request.requestHeaders) addHeaders(fmt, "Request Headers:", request.requestHeaders);
-  if (request.requestBody) {
+  if (request.requestBodyNotCaptured) {
+    fmt.text("Request Body:").separator("\u2501", 70);
+    fmt.text(`(not captured: ${request.requestBodyNotCaptured})`);
+    fmt.blank();
+  } else if (request.requestBody) {
     fmt.text("Request Body:").separator("\u2501", 70);
     fmt.text(request.requestBody);
     fmt.blank();
@@ -19711,6 +19692,8 @@ function formatActionOutput(done, details, result, options = {}) {
   if (requests.length > 0) {
     fmt.blank().section(formatTriggeredRequestsTitle(result.triggeredRequests ?? [], omitted), requests);
   }
+  if (result.downloads?.length) fmt.blank();
+  for (const download of result.downloads ?? []) fmt.text(downloadText(download));
   for (const dialog of result.dialogs ?? []) {
     fmt.blank();
     fmt.text(`Dialog: ${dialogConsoleText(dialog)}`);
@@ -19912,9 +19895,9 @@ init_url();
 var MAX_VALUE_LENGTH2 = 40;
 function fileName(src) {
   if (/^(data|blob):/i.test(src)) return src;
-  const path7 = src.split(/[?#]/)[0] ?? src;
-  const name = path7.substring(path7.lastIndexOf("/") + 1);
-  return name && name !== path7 ? `\u2026/${name}` : src;
+  const path8 = src.split(/[?#]/)[0] ?? src;
+  const name = path8.substring(path8.lastIndexOf("/") + 1);
+  return name && name !== path8 ? `\u2026/${name}` : src;
 }
 function hostOf(src) {
   const parsed = /^https?:/i.test(src) ? safeParseUrl(src) : null;
@@ -20043,7 +20026,7 @@ init_elementInfo();
 init_frameScopedConnection();
 init_logging();
 init_errors();
-var log26 = createLogger("dom");
+var log24 = createLogger("dom");
 function childFrameIds(tree) {
   return (tree?.childFrames ?? []).flatMap((child) => [child.frame.id, ...childFrameIds(child)]);
 }
@@ -20765,9 +20748,34 @@ async function audit(checks, options) {
   return { success: true, data: response.data };
 }
 
+// src/commands/dom/helpers/evalResult.ts
+init_constants();
+init_strings();
+function boundEvalResult(value, length) {
+  if (typeof value === "string") {
+    const { text, truncatedFrom } = capLength(value, MAX_VALUE_LENGTH);
+    return { result: text, ...truncatedFrom !== void 0 && { truncatedFrom } };
+  }
+  if (Array.isArray(value)) return boundArray(value, length ?? value.length);
+  if (value === null || typeof value !== "object") return { result: value };
+  const json = JSON.stringify(value);
+  return json.length > MAX_VALUE_LENGTH ? jsonStart(json) : { result: value };
+}
+function boundArray(value, count) {
+  const listed = value.slice(0, EVAL_JSON_ARRAY_LIMIT);
+  const listedJson = JSON.stringify(listed);
+  if (listedJson.length > MAX_VALUE_LENGTH) {
+    const json = listed.length === value.length ? listedJson : JSON.stringify(value);
+    return { ...jsonStart(json), count };
+  }
+  return listed.length < count ? { result: listed, count, omitted: count - listed.length } : { result: value };
+}
+function jsonStart(json) {
+  return { result: capLength(json, MAX_VALUE_LENGTH).text, truncatedFrom: json.length };
+}
+
 // src/commands/dom/eval.ts
 init_query();
-init_constants();
 init_messages();
 init_client();
 
@@ -20861,7 +20869,6 @@ function formatDomScreenshot(data) {
 // src/commands/dom/eval.ts
 init_commands();
 init_exitCodes();
-init_strings();
 async function handleDomEval(script, options) {
   await runCommand(
     async () => {
@@ -20874,7 +20881,7 @@ async function handleDomEval(script, options) {
           errorContext: { suggestion: err.suggestion }
         };
       }
-      const response = await domEval(script, options.frame);
+      const response = await domEval(script, options.frame, options.full);
       if (response.status === "error" || !response.data) {
         const suggestion = await frameErrorSuggestion(response, options.frame);
         return {
@@ -20884,7 +20891,7 @@ async function handleDomEval(script, options) {
           ...suggestion && { errorContext: { suggestion } }
         };
       }
-      const { value, type, subtype, frame, warning } = response.data;
+      const { value, type, subtype, length, frame, warning } = response.data;
       const hint = [
         ...frame !== void 0 ? [evalFrameLine(frame)] : [],
         ...warning ? [warningMessage(warning)] : []
@@ -20892,7 +20899,7 @@ async function handleDomEval(script, options) {
       return {
         success: true,
         data: {
-          ...jsonResult(value, options),
+          ...options.json && !options.full ? boundEvalResult(value, length) : { result: value },
           type,
           ...subtype && { subtype },
           ...frame !== void 0 && { frame },
@@ -20905,11 +20912,6 @@ async function handleDomEval(script, options) {
     (data) => formatDomEval(data, { full: options.full })
   );
 }
-function jsonResult(value, options) {
-  if (!options.json || options.full || typeof value !== "string") return { result: value };
-  const { text, truncatedFrom } = capLength(value, MAX_VALUE_LENGTH);
-  return { result: text, ...truncatedFrom !== void 0 && { truncatedFrom } };
-}
 async function frameErrorSuggestion(response, frame) {
   if (frame === void 0 || response.exitCode !== EXIT_CODES.RESOURCE_NOT_FOUND) {
     return response.suggestion;
@@ -21227,7 +21229,7 @@ function formatFormDiscovery(result) {
 init_logging();
 init_errors();
 init_exitCodes();
-var log27 = createLogger("dom");
+var log25 = createLogger("dom");
 function buildValidation(raw) {
   const hasNativeError = !raw.isValid && !raw.valueMissing && raw.validationMessage;
   const hasAriaError = raw.ariaInvalid;
@@ -21384,7 +21386,7 @@ async function cacheFormElements(forms, document2) {
   const elements = forms.flatMap((form) => [...form.fields, ...form.buttons]);
   const backendNodeIds = await resolveBackendNodeIds(elements.map((el) => el.selector)).catch(
     (error) => {
-      log27.debug(`Form fields not cached by node: ${getErrorMessage(error)}`);
+      log25.debug(`Form fields not cached by node: ${getErrorMessage(error)}`);
       return [];
     }
   );
@@ -21400,7 +21402,7 @@ async function cacheFormElements(forms, document2) {
     },
     document2
   );
-  log27.debug(`Cached ${elements.length} form elements`);
+  log25.debug(`Cached ${elements.length} form elements`);
 }
 async function handleFormCommand(options) {
   await runCommand(
@@ -22378,6 +22380,7 @@ function listedMatches(result, limit) {
 // src/commands/dom/screenshot.ts
 import { extname as extname2 } from "path";
 init_helpers();
+init_interrupt();
 init_outputFile();
 init_errors3();
 init_messages();
@@ -22386,7 +22389,7 @@ init_logging();
 init_directories();
 init_errors();
 init_exitCodes();
-var log28 = createLogger("dom");
+var log26 = createLogger("dom");
 var EXTENSION_FORMATS = {
   ".png": "png",
   ".jpg": "jpeg",
@@ -22407,34 +22410,27 @@ function resolveImageFormat(outputPath, requested) {
   }
   return requested ?? fromExtension ?? "png";
 }
-function buildPageScreenshotOptions(options) {
-  return filterDefined({
-    format: options.format,
-    quality: options.quality,
-    fullPage: options.fullPage,
-    noResize: options.resize === false,
-    scroll: options.scroll
-  });
-}
-function buildElementScreenshotOptions(options) {
-  return filterDefined({
-    format: options.format,
-    quality: options.quality,
-    noResize: options.resize === false,
-    padding: options.padding
-  });
+function buildScreenshotRequest(options, backendNodeId) {
+  const shared = {
+    format: options.format ?? "png",
+    ...filterDefined({ quality: options.quality }),
+    ...options.resize === false && { noResize: true }
+  };
+  if (backendNodeId !== void 0) {
+    return { ...shared, backendNodeId, ...filterDefined({ padding: options.padding }) };
+  }
+  return { ...shared, ...filterDefined({ fullPage: options.fullPage, scroll: options.scroll }) };
 }
 function hasElementTarget(options) {
   return options.selector !== void 0 || options.index !== void 0;
 }
 async function resolveElementNodeId(options) {
   if (options.selector !== void 0 && options.index !== void 0) {
-    return { backendNodeId: await selectMatch(options.selector, options.index) };
+    return selectMatch(options.selector, options.index);
   }
   if (options.index !== void 0) {
-    const resolver = DomElementResolver.getInstance();
-    const node = await resolver.getNodeIdForIndex(options.index);
-    return { backendNodeId: node.nodeId };
+    const node = await DomElementResolver.getInstance().getNodeIdForIndex(options.index);
+    return node.nodeId;
   }
   if (options.selector !== void 0) {
     return resolveSelector(options.selector);
@@ -22477,10 +22473,11 @@ function formatFrameFilename(frameNumber, format) {
   return `${String(frameNumber).padStart(3, "0")}.${format}`;
 }
 async function handlePageScreenshot(outputPath, options) {
+  const interrupt = abortOnInterrupt();
   await runCommand(
     async () => {
-      const screenshotOptions = buildPageScreenshotOptions(options);
-      const result = await capturePageScreenshot(outputPath, screenshotOptions);
+      const request = buildScreenshotRequest(options);
+      const result = await captureScreenshot(outputPath, request, interrupt);
       return { success: true, data: result };
     },
     options,
@@ -22488,12 +22485,14 @@ async function handlePageScreenshot(outputPath, options) {
   );
 }
 async function handleElementScreenshot(outputPath, options) {
+  const interrupt = abortOnInterrupt();
   await runCommand(
     async () => {
-      const nodeRef = await resolveElementNodeId(options);
-      const screenshotOptions = buildElementScreenshotOptions(options);
-      const result = await captureElementScreenshot(outputPath, nodeRef, screenshotOptions);
-      const elementResult = addElementInfo(result, options);
+      const lookup = resolveElementNodeId(options);
+      const backendNodeId = await unlessInterrupted(lookup, interrupt, screenshotInterrupted);
+      const request = buildScreenshotRequest(options, backendNodeId);
+      const shot = await captureScreenshot(outputPath, request, interrupt);
+      const elementResult = addElementInfo(shot, options);
       return { success: true, data: elementResult };
     },
     options,
@@ -22501,19 +22500,13 @@ async function handleElementScreenshot(outputPath, options) {
   );
 }
 async function captureSequenceFrame(outputPath, options) {
-  if (hasElementTarget(options)) {
-    const nodeRef = await resolveElementNodeId(options);
-    const elementOptions = buildElementScreenshotOptions(options);
-    await captureElementScreenshot(outputPath, nodeRef, elementOptions);
-  } else {
-    const pageOptions = buildPageScreenshotOptions(options);
-    await capturePageScreenshot(outputPath, pageOptions);
-  }
+  const backendNodeId = hasElementTarget(options) ? await resolveElementNodeId(options) : void 0;
+  await captureScreenshot(outputPath, buildScreenshotRequest(options, backendNodeId));
 }
 async function handleSequenceCapture(outputDir, options) {
   const fs19 = await import("fs");
-  const path7 = await import("path");
-  const absoluteDir = path7.resolve(outputDir);
+  const path8 = await import("path");
+  const absoluteDir = path8.resolve(outputDir);
   ensureDirectory(absoluteDir, fs19);
   const intervalRule = positiveIntRule({ name: "--interval", min: 100, max: 6e4, default: 1e3 });
   const limitRule = positiveIntRule({ name: "--limit", min: 1, max: 1e4, required: false });
@@ -22529,7 +22522,7 @@ async function handleSequenceCapture(outputDir, options) {
   while (!stopping) {
     frameCount++;
     const filename = formatFrameFilename(frameCount, format);
-    const outputPath = path7.join(absoluteDir, filename);
+    const outputPath = path8.join(absoluteDir, filename);
     try {
       await captureSequenceFrame(outputPath, options);
     } catch (error) {
@@ -22538,7 +22531,7 @@ async function handleSequenceCapture(outputDir, options) {
     if (options.json) {
       console.log(JSON.stringify(buildSuccessResponse({ frame: frameCount, path: outputPath })));
     } else {
-      log28.info(`Frame ${frameCount}: ${filename}`);
+      log26.info(`Frame ${frameCount}: ${filename}`);
     }
     if (limit > 0 && frameCount >= limit) break;
     await delay2(interval);
@@ -22721,8 +22714,8 @@ function registerDomCommands(program2) {
     "Image format: png or jpeg/jpg (default: from the file extension, else png)",
     screenshotFormatOption
   ).option("--quality <number>", "JPEG quality 0-100 (default: 90)", integerOption(0, 100)).option("--no-full-page", "Capture viewport only (default: full page)").option("--no-resize", "Disable auto-resize (full resolution)").option("--scroll <selector>", "Scroll element into view before capture").option("-f, --follow", "Continuous capture mode to directory").option("--interval <ms>", "Capture interval for --follow (default: 1000)").option("--limit <count>", "Max frames for --follow").option("-j, --json", "Output as JSON").action(
-    async (path7, target, options) => {
-      await handleDomScreenshot(path7, target, options);
+    async (path8, target, options) => {
+      await handleDomScreenshot(path8, target, options);
     }
   );
 }
@@ -22730,7 +22723,7 @@ function registerDomCommands(program2) {
 // src/commands/installSkill.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync2, readFileSync as readFileSync8, renameSync as renameSync2, rmSync as rmSync6, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname6, join as join7 } from "path";
+import { dirname as dirname7, join as join8 } from "path";
 init_errors3();
 init_messages();
 
@@ -22739,9 +22732,9 @@ init_formatting();
 init_commands();
 import { homedir as homedir2 } from "os";
 var PATH_INDENT = " ".repeat(2 + 6 + 2 + 9 + 2);
-function tildePath(path7) {
+function tildePath(path8) {
   const home = homedir2();
-  return path7.startsWith(`${home}/`) ? `~${path7.slice(home.length)}` : path7;
+  return path8.startsWith(`${home}/`) ? `~${path8.slice(home.length)}` : path8;
 }
 function addSkillTargets(fmt, skills) {
   fmt.text("bdg skill:");
@@ -22765,11 +22758,11 @@ function formatInstalledSkills(data) {
 init_logging();
 init_errors();
 init_exitCodes();
-var log29 = createLogger("bdg");
-var SKILL_SOURCE_PATH = join7(PACKAGE_ROOT, ".claude", "skills", "bdg", "SKILL.md");
+var log27 = createLogger("bdg");
+var SKILL_SOURCE_PATH = join8(PACKAGE_ROOT, ".claude", "skills", "bdg", "SKILL.md");
 var SKILL_ROOTS = {
-  claude: join7(".claude", "skills"),
-  agents: join7(".agents", "skills")
+  claude: join8(".claude", "skills"),
+  agents: join8(".agents", "skills")
 };
 function installSkill(targets, home = homedir3(), source = SKILL_SOURCE_PATH) {
   if (!existsSync11(source)) {
@@ -22784,7 +22777,7 @@ function installSkill(targets, home = homedir3(), source = SKILL_SOURCE_PATH) {
   const skills = [];
   const failures = [];
   for (const target of targets) {
-    const result = writeSkill(target, join7(home, SKILL_ROOTS[target], "bdg", "SKILL.md"), content);
+    const result = writeSkill(target, join8(home, SKILL_ROOTS[target], "bdg", "SKILL.md"), content);
     if ("error" in result) failures.push(result);
     else skills.push(result);
   }
@@ -22793,10 +22786,10 @@ function installSkill(targets, home = homedir3(), source = SKILL_SOURCE_PATH) {
 }
 function skillFailureError(failures, targets) {
   const other = failures.length === 1 ? targets.find((t) => t !== failures[0]?.target) : void 0;
-  const errors = failures.map(({ path: path7, error }) => {
+  const errors = failures.map(({ path: path8, error }) => {
     const code = error.code;
     return skillWriteFailedError(
-      path7,
+      path8,
       getErrorMessage(error),
       code === "ENOTDIR" || code === "EEXIST",
       other && `--${other}`
@@ -22808,30 +22801,30 @@ function skillFailureError(failures, targets) {
     EXIT_CODES.PERMISSION_DENIED
   );
 }
-function writeSkill(target, path7, content) {
-  const existing = existsSync11(path7) ? readFileSync8(path7, "utf-8") : void 0;
+function writeSkill(target, path8, content) {
+  const existing = existsSync11(path8) ? readFileSync8(path8, "utf-8") : void 0;
   if (existing === content) {
-    return { target, path: path7, status: "unchanged" };
+    return { target, path: path8, status: "unchanged" };
   }
-  const backup = existing === void 0 ? void 0 : `${path7}.bak`;
-  const temporary = `${path7}.tmp`;
-  let writing = path7;
+  const backup = existing === void 0 ? void 0 : `${path8}.bak`;
+  const temporary = `${path8}.tmp`;
+  let writing = path8;
   try {
-    mkdirSync2(dirname6(path7), { recursive: true });
+    mkdirSync2(dirname7(path8), { recursive: true });
     writeFileSync2(temporary, content);
     if (backup !== void 0) {
       writing = backup;
       rmSync6(backup, { force: true });
       writeFileSync2(backup, existing ?? "");
     }
-    writing = path7;
-    renameSync2(temporary, path7);
+    writing = path8;
+    renameSync2(temporary, path8);
   } catch (error) {
-    safeRemoveFile(temporary, "temporary skill copy", log29);
+    safeRemoveFile(temporary, "temporary skill copy", log27);
     return { target, path: writing, error };
   }
-  if (backup === void 0) return { target, path: path7, status: "installed" };
-  return { target, path: path7, status: "updated", backup };
+  if (backup === void 0) return { target, path: path8, status: "installed" };
+  return { target, path: path8, status: "updated", backup };
 }
 function selectedTargets(options) {
   const picked = Object.keys(SKILL_ROOTS).filter((target) => options[target]);
@@ -22862,7 +22855,7 @@ function registerInstallSkillCommand(program2) {
 
 // src/commands/network/har.ts
 import * as fs16 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 init_outputFile();
 init_client();
 init_paths();
@@ -22982,7 +22975,7 @@ function filterByResourceType(requests, types) {
 init_logging();
 init_suggestions();
 init_url();
-var log30 = createLogger("network");
+var log28 = createLogger("network");
 var SIZE_UNITS = {
   b: 1,
   kb: 1024,
@@ -23092,7 +23085,7 @@ function validateSizeValue(value) {
     parseSize(value);
     return null;
   } catch (error) {
-    log30.debug(
+    log28.debug(
       `Size parse failed for "${value}": ${error instanceof Error ? error.message : String(error)}`
     );
     return createError(
@@ -23278,27 +23271,359 @@ Multiple filters:
 
 // src/telemetry/har/builder.ts
 import { createRequire as createRequire2 } from "node:module";
+
+// src/telemetry/har/sanitizeBody.ts
+init_elementInfo();
+init_logging();
+init_errors();
+var log29 = createLogger("network");
+var REDACTED = "[redacted]";
+var SENSITIVE_FIELD = new RegExp(
+  `${SENSITIVE_NAME_SOURCE}|token|secret|api[-_]?key|authoriz|credential|jwt|private[-_]?key|access[-_]?key|session|signature|bearer|cookie|csrf|xsrf|refresh|oauth|(^|[^a-z])(auth|sid)([^a-z]|$)|auth[-_]?code|code[-_]?verifier`,
+  "i"
+);
+var FORM_BODY = /^(?!\[)[^\s=&{"]+=[^\s&]*(?:&[^\s=&]+=[^\s&]*)*$/;
+var JSON_LIKE_START = /^\uFEFF?(?:\)\]\}',?)?\s*(?:(?:\d+:)?(?:\d*-?(?:\/[^,]*,)?|[ac])[[{]|(?:data|event|id|retry):)/;
+var JSON_MIME = /json|event-stream/i;
+var DECODABLE_MIME = /^(?:application\/octet-stream|binary\/octet-stream|application\/x-www-form-urlencoded|text\/event-stream)?$|json/i;
+var BARE = /[^\s,:[\]{}"]+/y;
+var DOT = 46;
+var MAX_ENCODED_DEPTH = 3;
+var REDACTED_STRING = JSON.stringify(REDACTED);
+var UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function isSensitiveField2(name) {
+  return SENSITIVE_FIELD.test(name.replace(/([a-z])([A-Z])/g, "$1_$2"));
+}
+function redactOrReplaceWhole(text, redact, whole = REDACTED) {
+  try {
+    return redact(text);
+  } catch (error) {
+    log29.debug(`Body replaced whole, sanitizing failed: ${getErrorMessage(error)}`);
+    return whole;
+  }
+}
+function redactJwts(text, replacement) {
+  if (!text.includes("eyJ")) return text;
+  const parts = [];
+  let copied = 0;
+  let at = text.indexOf("eyJ");
+  while (at !== -1) {
+    const end = isJwtBoundary(text, at - 1) ? jwtEnd(text, at) : void 0;
+    if (end !== void 0 && isJwtBoundary(text, end)) {
+      parts.push(text.slice(copied, at), replacement);
+      copied = end;
+    }
+    at = text.indexOf("eyJ", Math.max(at + 3, copied));
+  }
+  if (parts.length === 0) return text;
+  parts.push(text.slice(copied));
+  return parts.join("");
+}
+function redactPairs(text, isSensitive, replacement) {
+  return text.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq === -1) return pair;
+    if (isSensitive(decodeName(pair.slice(0, eq)))) return `${pair.slice(0, eq)}=${replacement}`;
+    const value = pair.slice(eq + 1);
+    const redacted = redactJwts(value, replacement);
+    return redacted === value ? pair : `${pair.slice(0, eq + 1)}${redacted}`;
+  }).join("&");
+}
+function redactBody(text, mimeType) {
+  if (/multipart\/form-data/i.test(mimeType)) return redactMultipart(text, mimeType);
+  if (/x-www-form-urlencoded/i.test(mimeType)) return redactPairs(text, isSensitiveField2, REDACTED);
+  if (JSON_LIKE_START.test(text)) return redactJsonText(text, 0);
+  if (FORM_BODY.test(text)) return redactPairs(text, isSensitiveField2, REDACTED);
+  if (JSON_MIME.test(mimeType)) return redactJsonText(text, 0);
+  return redactJwts(text, REDACTED);
+}
+function redactBase64Body(base64, mimeType) {
+  if (!DECODABLE_MIME.test(mimeType.split(";")[0]?.trim() ?? "")) return base64;
+  let decoded;
+  try {
+    decoded = UTF8.decode(Buffer.from(base64, "base64"));
+  } catch (error) {
+    log29.debug(`Base64 body is not UTF-8: ${getErrorMessage(error)}`);
+    return base64;
+  }
+  const redacted = redactBody(decoded, mimeType);
+  return redacted === decoded ? base64 : Buffer.from(redacted, "utf8").toString("base64");
+}
+function decodeName(name) {
+  try {
+    return decodeURIComponent(name.replace(/\+/g, " "));
+  } catch (error) {
+    log29.debug(`Field name not decodable: ${getErrorMessage(error)}`);
+    return name;
+  }
+}
+function redactMultipart(text, mimeType) {
+  const match = /boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(mimeType);
+  const boundary = match?.[1] ?? match?.[2];
+  if (!boundary) return text;
+  const delimiter = `--${boundary}`;
+  return text.split(delimiter).map(redactPart).join(delimiter);
+}
+function redactPart(part) {
+  const headerEnd = part.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return part;
+  const name = /;\s*name="([^"]*)"/i.exec(part.slice(0, headerEnd))?.[1];
+  if (name === void 0 || !isSensitiveField2(name)) return redactJwts(part, REDACTED);
+  const valueEnd = part.endsWith("\r\n") ? part.length - 2 : part.length;
+  return `${part.slice(0, headerEnd + 4)}${REDACTED}${part.slice(valueEnd)}`;
+}
+function redactJsonText(text, depth) {
+  const scan2 = {
+    text,
+    parts: [],
+    copied: 0,
+    containers: [false],
+    key: void 0,
+    lineEnd: -1,
+    depth
+  };
+  let index = 0;
+  while (index < text.length) index = scanToken(scan2, index);
+  if (scan2.parts.length === 0) return text;
+  scan2.parts.push(text.slice(scan2.copied));
+  return scan2.parts.join("");
+}
+function scanToken(scan2, index) {
+  const char = scan2.text[index];
+  if (char === '"') return scanString(scan2, index);
+  if (char === "{" || char === "[") {
+    scan2.containers.push(takeValue(scan2));
+  } else if (char === "}" || char === "]") {
+    if (scan2.containers.length > 1) scan2.containers.pop();
+    scan2.key = void 0;
+  } else if (char === ",") {
+    scan2.key = void 0;
+  } else {
+    return scanBare(scan2, index);
+  }
+  return index + 1;
+}
+function scanString(scan2, start) {
+  const end = stringEnd(scan2, start);
+  if (isFollowedByColon(scan2.text, end)) {
+    scan2.key = isSensitiveField2(keyName(scan2.text, start, end));
+  } else if (takeValue(scan2)) {
+    replaceValue(scan2, start, end, REDACTED_STRING);
+  } else {
+    const encoded = redactEncodedJson(scan2, start, end);
+    if (encoded === void 0) redactStringJwts(scan2, start, end);
+    else replaceValue(scan2, start, end, encoded);
+  }
+  return end;
+}
+function redactStringJwts(scan2, start, end) {
+  const contentEnd = end - 1 > start && scan2.text[end - 1] === '"' ? end - 1 : end;
+  const content = scan2.text.slice(start + 1, contentEnd);
+  const redacted = redactJwts(content, REDACTED);
+  if (redacted !== content) replaceValue(scan2, start + 1, contentEnd, redacted);
+}
+function scanBare(scan2, index) {
+  BARE.lastIndex = index;
+  const bare = BARE.exec(scan2.text)?.[0];
+  if (bare === void 0) return index + 1;
+  const end = index + bare.length;
+  const isLiteral = /^[-\d]/.test(bare) || bare === "true" || bare === "false" || bare === "null";
+  if (!isLiteral && scan2.key !== true) return end;
+  if (takeValue(scan2) && bare !== "null") replaceValue(scan2, index, end, REDACTED_STRING);
+  return end;
+}
+function takeValue(scan2) {
+  const sensitive = scan2.key === true || scan2.containers[scan2.containers.length - 1] === true;
+  scan2.key = void 0;
+  return sensitive;
+}
+function replaceValue(scan2, start, end, replacement) {
+  scan2.parts.push(scan2.text.slice(scan2.copied, start), replacement);
+  scan2.copied = end;
+}
+function isJwtBoundary(text, index) {
+  if (index < 0 || index >= text.length) return true;
+  const code = text.charCodeAt(index);
+  return !isBase64UrlCode(code) && code !== DOT;
+}
+function jwtEnd(text, start) {
+  const first = segmentEnd(text, start + 3);
+  if (first - start < 8 || text[first] !== ".") return void 0;
+  const second = segmentEnd(text, first + 1);
+  if (second - first - 1 < 5 || text[second] !== ".") return void 0;
+  return segmentEnd(text, second + 1);
+}
+function segmentEnd(text, from) {
+  let index = from;
+  while (index < text.length && isBase64UrlCode(text.charCodeAt(index))) index++;
+  return index;
+}
+function isBase64UrlCode(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 45;
+}
+function redactEncodedJson(scan2, start, end) {
+  if (scan2.depth >= MAX_ENCODED_DEPTH || end - start < 2 || scan2.text[end - 1] !== '"') {
+    return void 0;
+  }
+  if (!/[[{]/.test(scan2.text.slice(start + 1, end - 1))) return void 0;
+  let decoded;
+  try {
+    decoded = JSON.parse(scan2.text.slice(start, end));
+  } catch (error) {
+    log29.debug(`String value not decodable: ${getErrorMessage(error)}`);
+    return void 0;
+  }
+  if (!JSON_LIKE_START.test(decoded)) return void 0;
+  const redacted = redactJsonText(decoded, scan2.depth + 1);
+  return redacted === decoded ? void 0 : JSON.stringify(redacted);
+}
+function stringEnd(scan2, start) {
+  const { text } = scan2;
+  let from = start + 1;
+  for (; ; ) {
+    const quote = text.indexOf('"', from);
+    const lineEnd = nextLineEnd(scan2, from);
+    if (quote === -1 || lineEnd < quote) {
+      return lineEnd > from && text[lineEnd - 1] === "\r" ? lineEnd - 1 : lineEnd;
+    }
+    let backslashes = 0;
+    while (text[quote - 1 - backslashes] === "\\" && quote - 1 - backslashes > start) {
+      backslashes++;
+    }
+    if (backslashes % 2 === 0) return quote + 1;
+    from = quote + 1;
+  }
+}
+function nextLineEnd(scan2, from) {
+  if (scan2.lineEnd < from) {
+    const lineEnd = scan2.text.indexOf("\n", from);
+    scan2.lineEnd = lineEnd === -1 ? scan2.text.length : lineEnd;
+  }
+  return scan2.lineEnd;
+}
+function isFollowedByColon(text, index) {
+  let next = index;
+  while (next < text.length && " 	\n\r".includes(text.charAt(next))) next++;
+  return text[next] === ":";
+}
+function keyName(text, start, end) {
+  const raw = text.slice(start + 1, end - 1);
+  if (!raw.includes("\\")) return raw;
+  try {
+    return JSON.parse(text.slice(start, end));
+  } catch (error) {
+    log29.debug(`Key not decodable: ${getErrorMessage(error)}`);
+    return raw;
+  }
+}
+
+// src/telemetry/har/sanitize.ts
+var URL_REDACTED = encodeURIComponent(REDACTED);
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "authentication",
+  "cookie",
+  "set-cookie"
+]);
+var SENSITIVE_CUSTOM_HEADER = /^x-.*(key|token|secret|auth)/i;
+var SENSITIVE_HEADER_SEGMENT = /(^|-)(api-?key|apikey|token|secret|jwt|subscription-key|session(-?id)?)(-|$)/i;
+var URL_HEADERS = /* @__PURE__ */ new Set(["location", "referer"]);
+var SENSITIVE_URL_PARAM = /^(code|sig|key)$/i;
+var BASE64_REDACTED = Buffer.from(REDACTED).toString("base64");
+var TEXT_OPCODE = 1;
+var BINARY_OPCODE2 = 2;
+function sanitizeEntry(entry) {
+  const { request, response, _webSocketMessages: messages } = entry;
+  const postData = request.postData;
+  return {
+    ...entry,
+    request: {
+      ...request,
+      url: redactUrl(request.url),
+      cookies: request.cookies.map(redactCookie),
+      headers: request.headers.map(redactHeader),
+      queryString: request.queryString.map(redactQueryParam),
+      ...postData?.text !== void 0 && {
+        postData: {
+          ...postData,
+          text: redactOrReplaceWhole(postData.text, (text) => redactBody(text, postData.mimeType))
+        }
+      }
+    },
+    response: {
+      ...response,
+      cookies: response.cookies.map(redactCookie),
+      headers: response.headers.map(redactHeader),
+      redirectURL: redactUrl(response.redirectURL),
+      content: redactContent(response.content)
+    },
+    ...messages && { _webSocketMessages: messages.map(redactWebSocketMessage) }
+  };
+}
+function redactContent(content) {
+  const { text, mimeType } = content;
+  if (text === void 0) return content;
+  const redacted = content.encoding === "base64" ? redactOrReplaceWhole(text, (body) => redactBase64Body(body, mimeType), BASE64_REDACTED) : redactOrReplaceWhole(text, (body) => redactBody(body, mimeType));
+  return redacted === text ? content : { ...content, text: redacted };
+}
+function redactWebSocketMessage(message) {
+  if (message.opcode !== TEXT_OPCODE && message.opcode !== BINARY_OPCODE2) return message;
+  const data = message.opcode === TEXT_OPCODE ? redactOrReplaceWhole(message.data, (text) => redactBody(text, "")) : redactOrReplaceWhole(message.data, (text) => redactBase64Body(text, ""), BASE64_REDACTED);
+  return data === message.data ? message : { ...message, data };
+}
+function isSensitiveHeader(name) {
+  return SENSITIVE_HEADERS.has(name.toLowerCase()) || SENSITIVE_CUSTOM_HEADER.test(name) || SENSITIVE_HEADER_SEGMENT.test(name);
+}
+function redactHeader(header) {
+  if (isSensitiveHeader(header.name)) return { ...header, value: REDACTED };
+  if (!URL_HEADERS.has(header.name.toLowerCase())) return header;
+  const value = redactUrl(header.value);
+  return value === header.value ? header : { ...header, value };
+}
+function redactCookie(cookie) {
+  return { ...cookie, value: REDACTED };
+}
+function isSensitiveParam(name) {
+  return isSensitiveField2(name) || SENSITIVE_URL_PARAM.test(name);
+}
+function redactQueryParam(param) {
+  return isSensitiveParam(param.name) ? { ...param, value: REDACTED } : param;
+}
+function redactUrl(url) {
+  const hash = url.indexOf("#");
+  const beforeHash = hash === -1 ? url : url.slice(0, hash);
+  const fragment = hash === -1 ? "" : `#${redactPairs(url.slice(hash + 1), isSensitiveParam, URL_REDACTED)}`;
+  const question = beforeHash.indexOf("?");
+  if (question === -1) return beforeHash + fragment;
+  const query = redactPairs(beforeHash.slice(question + 1), isSensitiveParam, URL_REDACTED);
+  return `${beforeHash.slice(0, question)}?${query}${fragment}`;
+}
+
+// src/telemetry/har/builder.ts
 var requireBuiltin = createRequire2(import.meta.url);
 var UNKNOWN_TIMING = -1;
 var DEFAULT_HTTP_VERSION = "HTTP/1.1";
-function buildHAR(requests, metadata) {
-  const entries = [...requests].sort((a, b) => a.timestamp - b.timestamp).map(buildEntry);
-  const log34 = {
+function buildHAR(requests, metadata, options = {}) {
+  const built = [...requests].sort((a, b) => a.timestamp - b.timestamp).map(buildEntry);
+  const entries = options.includeSensitive ? built : built.map(sanitizeEntry);
+  const log33 = {
     version: "1.2",
     creator: {
       name: "bdg",
       version: metadata.version,
       comment: "Browser Debugger CLI - https://github.com/szymdzum/browser-debugger-cli"
     },
-    entries
+    entries,
+    ...!options.includeSensitive && { comment: harSanitizedComment() }
   };
   if (metadata.chromeVersion) {
-    log34.browser = {
+    log33.browser = {
       name: "Chrome",
       version: metadata.chromeVersion
     };
   }
-  return { log: log34 };
+  return { log: log33 };
 }
 function buildEntry(req) {
   const timings = buildTimings(req);
@@ -23329,7 +23654,8 @@ function buildWebSocketMessage(frame) {
     type: frame.direction === "sent" ? "send" : "receive",
     time: frame.timestamp / 1e3,
     opcode: frame.opcode,
-    data: frame.payloadData
+    data: frame.payloadData,
+    ...frame.truncatedFrom !== void 0 && { _truncatedFrom: frame.truncatedFrom }
   };
 }
 function buildRequest(req) {
@@ -23342,7 +23668,7 @@ function buildRequest(req) {
     headers: convertHeaders(req.requestHeaders),
     queryString: extractQueryParams(url),
     headersSize: estimateRequestHeadersSize(req.method, req.url, req.requestHeaders),
-    bodySize: req.requestBody ? Buffer.byteLength(req.requestBody, "utf-8") : 0
+    bodySize: requestBodySize(req)
   };
   const postData = buildPostData(req);
   if (postData) {
@@ -23390,13 +23716,17 @@ function contentLength(req) {
   const bytes = value === void 0 ? NaN : Number(value);
   return Number.isInteger(bytes) && bytes >= 0 ? bytes : void 0;
 }
+function requestBodySize(req) {
+  if (!req.requestBody) return 0;
+  if (skippedBodyReason(req.requestBody) !== void 0) return -1;
+  return Buffer.byteLength(req.requestBody, "utf-8");
+}
 function buildPostData(req) {
   if (!req.requestBody) return void 0;
-  const contentType = getHeader(req.requestHeaders, "content-type") ?? "text/plain";
-  return {
-    mimeType: contentType,
-    text: req.requestBody
-  };
+  const mimeType = getHeader(req.requestHeaders, "content-type") ?? "text/plain";
+  const skipped = skippedBodyReason(req.requestBody);
+  if (skipped !== void 0) return { mimeType, comment: `Body not captured: ${skipped}` };
+  return { mimeType, text: req.requestBody };
 }
 function span(start, end) {
   if (start === void 0 || end === void 0 || start < 0 || end < 0 || end < start) {
@@ -23509,8 +23839,8 @@ function extractRedirectURL(req) {
 }
 function estimateRequestHeadersSize(method, url, headers) {
   const parsedUrl = new URL(url);
-  const path7 = parsedUrl.pathname + parsedUrl.search;
-  const requestLine = `${method} ${path7} ${DEFAULT_HTTP_VERSION}\r
+  const path8 = parsedUrl.pathname + parsedUrl.search;
+  const requestLine = `${method} ${path8} ${DEFAULT_HTTP_VERSION}\r
 `;
   const headersString = headers ? Object.entries(headers).map(([name, value]) => `${name}: ${value}\r
 `).join("") : "";
@@ -23642,6 +23972,13 @@ function formatSessionStatus(metadata, pid, activity, pageState, verbose = false
     if (activity.lastConsoleMessageAt) {
       fmt.keyValue("  Last Message", formatTimeAgo(activity.lastConsoleMessageAt), 18);
     }
+    const downloadRows = [
+      ...activity.downloads?.length ? [downloadsSummary(activity.downloads)] : [],
+      ...activity.downloadsWarning ? [`\u26A0 ${activity.downloadsWarning}`] : []
+    ];
+    downloadRows.forEach(
+      (row, index) => index === 0 ? fmt.keyValue("Downloads", row, 18) : fmt.text(`${" ".repeat(18)}${row}`)
+    );
   }
   fmt.blank().text("Collectors").separator("\u2501", 50);
   const activeTelemetry = metadata.activeTelemetry ?? ["network", "console", "dom"];
@@ -23778,6 +24115,7 @@ function buildPreviewJsonData(output, options) {
     ...output.partial !== void 0 && { partial: output.partial },
     ...output.totals && { totals: output.totals },
     ...output.pageCrashedAt !== void 0 && { pageCrashedAt: output.pageCrashedAt },
+    ...output.downloads && { downloads: output.downloads },
     ...pick("network") && output.data.network && { network: last(output.data.network) },
     ...pick("console") && output.data.console && {
       console: last(output.data.console)?.map((message) => capMessageText(message, options.full))
@@ -23862,6 +24200,8 @@ function formatPreviewCompact(output, options) {
       fmt.blank();
     }
   }
+  if (output.downloads?.length)
+    fmt.text(`Downloads: ${downloadsSummary(output.downloads)}`).blank();
   if (!options.follow) {
     fmt.tip(compactTipsMessage());
   }
@@ -23950,6 +24290,9 @@ function formatPreviewVerbose(output, options) {
       fmt.blank();
     }
   }
+  if (output.downloads?.length) {
+    fmt.keyValue("Downloads", downloadsSummary(output.downloads), 18).blank();
+  }
   if (!options.follow) {
     fmt.tip(verboseCommandsMessage());
   }
@@ -24073,7 +24416,7 @@ function registerDocumentCommand(networkCmd) {
 }
 
 // src/commands/network/har.ts
-var log31 = createLogger("network");
+var log30 = createLogger("network");
 function generateHARFilename() {
   const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
@@ -24083,10 +24426,10 @@ function generateHARFilename() {
   const minutes = String(now.getMinutes()).padStart(2, "0");
   const seconds = String(now.getSeconds()).padStart(2, "0");
   const base = `capture-${year}-${month}-${day}-${hours}${minutes}${seconds}`;
-  const sessionDir = path6.dirname(getSessionFilePath("OUTPUT"));
-  let candidate = path6.join(sessionDir, `${base}.har`);
+  const sessionDir = path7.dirname(getSessionFilePath("OUTPUT"));
+  let candidate = path7.join(sessionDir, `${base}.har`);
   for (let n = 2; fs16.existsSync(candidate); n++) {
-    candidate = path6.join(sessionDir, `${base}-${n}.har`);
+    candidate = path7.join(sessionDir, `${base}-${n}.har`);
   }
   return candidate;
 }
@@ -24096,22 +24439,26 @@ async function getChromeVersion() {
     const product = response.data?.result?.product;
     return product?.split("/")[1];
   } catch (error) {
-    log31.debug(`Could not read Chrome version: ${getErrorMessage(error)}`);
+    log30.debug(`Could not read Chrome version: ${getErrorMessage(error)}`);
     return void 0;
   }
 }
 function formatHARExport(data) {
   if ("log" in data) return JSON.stringify(data, null, 2);
-  const filterNote = data.filtered ? " (filtered)" : "";
-  return `\u2713 Exported ${data.entries} requests${filterNote} to ${data.file}`;
+  return harExportedMessage(data);
 }
+var HAR_FILE_MODE = 384;
 var STDOUT_PATH = "-";
 var filterDslOption = new Option(
   "--filter <dsl>",
   'Filter requests using DevTools DSL (e.g., "status-code:>=400")'
 );
+var includeSensitiveOption = new Option(
+  "--include-sensitive",
+  "Keep credentials (auth/cookie/API key headers, cookie values, URL tokens, password and token body fields); redacted by default"
+);
 function registerHarCommand(networkCmd) {
-  networkCmd.command("har [output-file]").addHelpText("after", "\nUse - as the output file to write the HAR to stdout.").description("Export network data as HAR 1.2 format").addOption(jsonOption()).addOption(filterDslOption).action(async (outputFile, options) => {
+  networkCmd.command("har [output-file]").addHelpText("after", "\nUse - as the output file to write the HAR to stdout.").description("Export network data as HAR 1.2 format").addOption(jsonOption()).addOption(filterDslOption).addOption(includeSensitiveOption).action(async (outputFile, options) => {
     await runCommand(
       async () => {
         let requests = await getNetworkRequests();
@@ -24126,20 +24473,26 @@ function registerHarCommand(networkCmd) {
         const outputPath = outputFile ?? generateHARFilename();
         if (outputPath !== STDOUT_PATH) assertFilePath(outputPath, ".har");
         const chromeVersion = await getChromeVersion();
-        const har = buildHAR(requests, {
-          version: VERSION,
-          ...chromeVersion && { chromeVersion }
-        });
+        const includeSensitive = options.includeSensitive === true;
+        const har = buildHAR(
+          requests,
+          { version: VERSION, ...chromeVersion && { chromeVersion } },
+          { includeSensitive }
+        );
         if (outputPath === STDOUT_PATH) return { success: true, data: har };
-        const file = await writeOutputFile(outputPath, JSON.stringify(har, null, 2), ".har");
-        return {
-          success: true,
-          data: {
-            file,
-            entries: har.log.entries.length,
-            filtered
-          }
+        const file = await writeOutputFile(
+          outputPath,
+          JSON.stringify(har, null, 2),
+          ".har",
+          HAR_FILE_MODE
+        );
+        const data = {
+          file,
+          entries: har.log.entries.length,
+          filtered,
+          sanitized: !includeSensitive
         };
+        return { success: true, data };
       },
       options,
       formatHARExport
@@ -24898,13 +25251,13 @@ import * as fs17 from "fs";
 init_paths();
 init_logging();
 init_directories();
-var log32 = createLogger("session");
+var log31 = createLogger("session");
 function readPortFile(portPath) {
   try {
     const port = parseInt(fs17.readFileSync(portPath, "utf-8").trim(), 10);
     return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
   } catch (error) {
-    logDebugError(log32, `read ${portPath}`, error);
+    logDebugError(log31, `read ${portPath}`, error);
     return null;
   }
 }
@@ -24956,7 +25309,7 @@ function selectSession(optionValue) {
 // src/session/sessionList.ts
 init_logging();
 init_sessionCommand();
-var log33 = createLogger("session");
+var log32 = createLogger("session");
 function toRunningSession(name, data) {
   const meta = data.sessionMetadata;
   const state = meta ? "active" : data.ending ? "ending" : "starting";
@@ -24975,11 +25328,15 @@ async function describeSession(entry) {
   const socketPath = sessionFilePathIn(dir, "DAEMON_SOCKET");
   const probe = await probeDaemonSocket(socketPath);
   if (probe !== "alive") return describeWithoutSocket(entry, probe);
+  const untrusted = secureSessionDir(dir);
+  if (untrusted) {
+    return { name, state: "untrusted", untrusted: `${untrusted.dir}: ${untrusted.reason}` };
+  }
   try {
     const response = await getStatus(socketPath);
     if (response.status === "ok" && response.data) return toRunningSession(name, response.data);
   } catch (error) {
-    logDebugError(log33, `get status of ${dir}`, error);
+    logDebugError(log32, `get status of ${dir}`, error);
   }
   return { name, state: "unresponsive" };
 }
@@ -25018,7 +25375,7 @@ function leftoverPort(dir) {
     const meta = JSON.parse(fs18.readFileSync(sessionFilePathIn(dir, "METADATA"), "utf8"));
     if (typeof meta.port === "number") return meta.port;
   } catch (error) {
-    logDebugError(log33, `read the metadata in ${dir}`, error);
+    logDebugError(log32, `read the metadata in ${dir}`, error);
   }
   return readPortFile(sessionFilePathIn(dir, "PORT"));
 }
@@ -25031,7 +25388,7 @@ function isSameDir(a, b) {
     const second = fs18.statSync(b);
     return first.ino === second.ino && first.dev === second.dev;
   } catch (error) {
-    logDebugError(log33, `compare ${a} with ${b}`, error);
+    logDebugError(log32, `compare ${a} with ${b}`, error);
     return false;
   }
 }
@@ -25090,6 +25447,15 @@ function formatSessionList(data) {
   if (ended.length > 0) {
     fmt.blank().section("Ended without bdg stop:", ended);
   }
+  const untrusted = data.sessions.flatMap(
+    ({ name, untrusted: why }) => why ? [untrustedSessionText(name ?? DEFAULT_SESSION_LABEL, why)] : []
+  );
+  if (untrusted.length > 0) {
+    fmt.blank().section(
+      "Directory not safe to use (not asked; bdg status --session <name> says how to fix it):",
+      untrusted
+    );
+  }
   const cleanups = data.sessions.flatMap((session) => session.cleanup ? [session.cleanup] : []);
   if (cleanups.length > 0) {
     fmt.hints("Crashed or stale sessions; clean up with:", cleanups);
@@ -25207,6 +25573,7 @@ function registerStatusCommand(program2) {
           }
           return { success: true, data: withSessionName(jsonOutput) };
         } catch (error) {
+          if (error instanceof CommandError) throw error;
           const errorMessage = getErrorMessage(error);
           if (error instanceof IPCTimeoutError) {
             const err = sessionNotRespondingError(error.timeoutMs / 1e3);
@@ -25255,6 +25622,7 @@ function registerStatusCommand(program2) {
 }
 
 // src/commands/stop.ts
+init_errors3();
 init_client();
 init_transport();
 init_formatting();
@@ -25325,7 +25693,7 @@ function registerStopCommand(program2) {
             };
           }
         } catch (error) {
-          if (error instanceof IPCTimeoutError) throw error;
+          if (error instanceof IPCTimeoutError || error instanceof CommandError) throw error;
           const errorMessage = getErrorMessage(error);
           if (isDaemonNotRunningError(errorMessage)) {
             return {