pi-agent-browser-native 0.9.5 → 0.9.7

package/dist/packaged/lib/results/snapshot.js

@@ -0,0 +1,2800 @@
+// dist/extensions/agent-browser/lib/parsing.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parsePositiveInteger(rawValue) {
+  if (typeof rawValue !== "string") {
+    return void 0;
+  }
+  const normalizedValue = rawValue.trim();
+  if (!/^\d+$/.test(normalizedValue)) {
+    return void 0;
+  }
+  const parsedValue = Number(normalizedValue);
+  if (!Number.isSafeInteger(parsedValue) || parsedValue <= 0) {
+    return void 0;
+  }
+  return parsedValue;
+}
+
+// dist/extensions/agent-browser/lib/results/editable-ref-evidence.js
+var EDITABLE_REF_EVIDENCE_KEYS = [
+  "editable",
+  "contentEditable",
+  "contenteditable",
+  "isContentEditable"
+];
+var EDITABLE_FALSE_TEXT_PATTERN = /\b(?:contenteditable|editable)\s*=\s*["']?(?:false|0)["']?/i;
+var EDITABLE_ASSIGNMENT_TEXT_PATTERN = /\b(contenteditable|editable)\s*=\s*("[^"]*"|'[^']*'|[^\s,\]]+)/gi;
+var EDITABLE_BARE_TEXT_PATTERN = /\b(?:contenteditable|editable)\b(?!\s*=)/i;
+function parseEditableEvidenceValue(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().replace(/^["']|["']$/g, "").toLowerCase();
+  if (["false", "0", "no"].includes(normalized)) {
+    return false;
+  }
+  if (["", "true", "1", "yes", "plaintext-only"].includes(normalized)) {
+    return true;
+  }
+  return void 0;
+}
+function stripLeadingSnapshotAccessibleName(text) {
+  return text.replace(/^(\s*[-*]\s+\S+\s+)(?:"[^"]*"|'[^']*')/, "$1");
+}
+function parseEditableAssignments(markerText) {
+  let hasPositiveAssignment = false;
+  for (const match of markerText.matchAll(EDITABLE_ASSIGNMENT_TEXT_PATTERN)) {
+    const key = match[1]?.toLowerCase();
+    const evidence = parseEditableEvidenceValue(match[2]);
+    if (evidence === false) {
+      return false;
+    }
+    if (evidence === true && (key === "contenteditable" || key === "editable")) {
+      hasPositiveAssignment = true;
+    }
+  }
+  return hasPositiveAssignment ? true : void 0;
+}
+function parseEditableEvidenceText(text) {
+  if (text === void 0 || text.length === 0) {
+    return void 0;
+  }
+  const markerText = stripLeadingSnapshotAccessibleName(text);
+  if (EDITABLE_FALSE_TEXT_PATTERN.test(markerText)) {
+    return false;
+  }
+  const assignment = parseEditableAssignments(markerText);
+  if (assignment !== void 0) {
+    return assignment;
+  }
+  return EDITABLE_BARE_TEXT_PATTERN.test(markerText) ? true : void 0;
+}
+function getStructuredEditableEvidence(ref) {
+  if (!ref) {
+    return void 0;
+  }
+  let hasPositiveEvidence = false;
+  for (const key of EDITABLE_REF_EVIDENCE_KEYS) {
+    const evidence = parseEditableEvidenceValue(ref[key]);
+    if (evidence === false) {
+      return false;
+    }
+    if (evidence === true) {
+      hasPositiveEvidence = true;
+    }
+  }
+  return hasPositiveEvidence ? true : void 0;
+}
+function getEditableRefEvidence(options) {
+  const structuredEvidence = getStructuredEditableEvidence(options.ref);
+  if (structuredEvidence === false) {
+    return false;
+  }
+  let hasPositiveEvidence = structuredEvidence === true;
+  const textEvidence = parseEditableEvidenceText(options.text);
+  if (textEvidence === false) {
+    return false;
+  }
+  if (textEvidence === true) {
+    hasPositiveEvidence = true;
+  }
+  return hasPositiveEvidence ? true : void 0;
+}
+
+// dist/extensions/agent-browser/lib/results/text.js
+function stringifyUnknown(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    return typeof serialized === "string" ? serialized : "";
+  } catch {
+    return stringifyFallback(value);
+  }
+}
+function stringifyFallback(value) {
+  if (typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") {
+    return String(value);
+  }
+  return Object.prototype.toString.call(value);
+}
+function countLines(text) {
+  return text.length === 0 ? 0 : text.split("\n").length;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(1, maxChars - 1))}\u2026`;
+}
+function compareRefIds(left, right) {
+  const leftMatch = left.match(/^(?:[a-zA-Z]+)?(\d+)$/);
+  const rightMatch = right.match(/^(?:[a-zA-Z]+)?(\d+)$/);
+  if (leftMatch && rightMatch) {
+    return Number(leftMatch[1]) - Number(rightMatch[1]);
+  }
+  return left.localeCompare(right);
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-refs.js
+function getFullSnapshotData(data) {
+  if (!isRecord(data)) {
+    return void 0;
+  }
+  if (!isRecord(data.snapshot)) {
+    return data;
+  }
+  return data.snapshot.kind === "full" ? { ...data, snapshot: data.snapshot.tree, refs: data.snapshot.refs } : void 0;
+}
+function getSnapshotRefRecord(data) {
+  const full = getFullSnapshotData(data);
+  return full && isRecord(full.refs) ? full.refs : void 0;
+}
+function getSnapshotRefEntries(data) {
+  const refs = getSnapshotRefRecord(data);
+  if (!refs) {
+    return [];
+  }
+  return Object.entries(refs).map(([id, value]) => {
+    if (!isRecord(value)) {
+      return { id, name: "", role: "unknown" };
+    }
+    const name = typeof value.name === "string" ? normalizeWhitespace(value.name) : "";
+    const role = typeof value.role === "string" && value.role.length > 0 ? value.role : "unknown";
+    const isEditable = getEditableRefEvidence({ ref: value });
+    return { id, isEditable, name, refData: value, role };
+  }).sort((a, b) => compareRefIds(a.id, b.id));
+}
+function isEditableSnapshotLine(line) {
+  const editableEvidence = getEditableRefEvidence({ text: line.raw });
+  if (editableEvidence !== void 0) {
+    return editableEvidence;
+  }
+  return line.role === "searchbox" || line.role === "textbox" || line.role === "combobox" ? true : void 0;
+}
+function getSnapshotRefRole(entry, editableEvidence) {
+  const rawRole = typeof entry.role === "string" && entry.role.length > 0 ? entry.role : "unknown";
+  const normalizedRole = rawRole.toLowerCase();
+  if ((normalizedRole === "generic" || normalizedRole === "unknown") && editableEvidence === true) {
+    return "textbox";
+  }
+  return rawRole;
+}
+function getSnapshotRefFallbackRole(role, line) {
+  if (role !== "unknown" && role !== "generic") {
+    return role;
+  }
+  return line && line.role !== "unknown" ? line.role : role;
+}
+function resolveSnapshotRefEditableEvidence(evidence, line) {
+  if (evidence !== void 0) {
+    return evidence;
+  }
+  return line !== void 0 && isEditableSnapshotLine(line) === true && !["unknown", "generic"].includes(line.role);
+}
+function enrichSnapshotRefEntries(refEntries, snapshotLines) {
+  const lineByRef = /* @__PURE__ */ new Map();
+  for (const line of snapshotLines) {
+    if (line.ref === void 0 || line.ref.length === 0 || lineByRef.has(line.ref)) {
+      continue;
+    }
+    lineByRef.set(line.ref, line);
+  }
+  return refEntries.map((entry) => {
+    const line = lineByRef.get(entry.id);
+    const editableEvidence = getEditableRefEvidence({ ref: entry.refData, text: line?.raw });
+    const isEditable = resolveSnapshotRefEditableEvidence(editableEvidence, line);
+    const roleFromRefOrLine = getSnapshotRefFallbackRole(entry.role, line);
+    const role = getSnapshotRefRole({ role: roleFromRefOrLine }, isEditable);
+    return {
+      ...entry,
+      isEditable,
+      lineIndex: line?.index,
+      name: entry.name.length > 0 ? entry.name : line?.name ?? "",
+      role
+    };
+  });
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-content.js
+function getSnapshotText(data) {
+  const full = getFullSnapshotData(data);
+  if (typeof full?.snapshot === "string") {
+    return full.snapshot;
+  }
+  return isRecord(data.snapshot) ? JSON.stringify(data.snapshot) : void 0;
+}
+function getSnapshotOrigin(data) {
+  return typeof data.origin === "string" ? data.origin : "(unknown origin)";
+}
+function formatSnapshotSummary(data) {
+  const origin = typeof data.origin === "string" ? data.origin : "page";
+  if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
+    return `Snapshot ${stringifyUnknown(data.snapshot.kind)}: revision ${stringifyUnknown(data.snapshot.revision)} on ${origin}`;
+  }
+  return `Snapshot: ${Object.keys(getSnapshotRefRecord(data) ?? {}).length} refs on ${origin}`;
+}
+function formatRawSnapshotText(data) {
+  const origin = getSnapshotOrigin(data);
+  const refs = Object.keys(getSnapshotRefRecord(data) ?? {}).length;
+  const snapshot = getSnapshotText(data);
+  if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
+    return `Origin: ${origin}
+${formatSnapshotSummary(data)}
+
+${snapshot ?? "undefined"}`;
+  }
+  if (snapshot === void 0 || snapshot.length === 0) {
+    return `Origin: ${origin}
+Refs: ${refs}
+
+(no interactive elements)`;
+  }
+  return `Origin: ${origin}
+Refs: ${refs}
+
+${snapshot}`;
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-high-value-controls.js
+var SNAPSHOT_HIGH_VALUE_EDITABLE_REF_FILL_TARGET_LINES = 4;
+var SNAPSHOT_HIGH_VALUE_SURFACE_REF_FILL_TARGET_LINES = 3;
+var SNAPSHOT_HIGH_VALUE_PRIMARY_ACTION_REF_FILL_TARGET_LINES = 3;
+var SNAPSHOT_HIGH_VALUE_NAMED_LINK_REF_FILL_TARGET_LINES = 6;
+var SNAPSHOT_HIGH_VALUE_LINK_NAME_MAX_LENGTH = 80;
+var SNAPSHOT_HIGH_VALUE_CONTROL_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "checkbox",
+  "combobox",
+  "link",
+  "menuitem",
+  "option",
+  "radio",
+  "searchbox",
+  "tab",
+  "textbox"
+]);
+var SNAPSHOT_HIGH_VALUE_CONTROL_ROLE_PRIORITY = {
+  searchbox: 0,
+  textbox: 1,
+  combobox: 2,
+  button: 3,
+  link: 4,
+  tab: 5,
+  checkbox: 6,
+  radio: 7,
+  option: 8,
+  menuitem: 9
+};
+var SNAPSHOT_SURFACE_CONTROL_NAME_PATTERNS = [
+  /\b(?:agents?|browser|canvas|chat|editor|panel|pane|preview|surface|tab|terminal|thread|view|window|workspace)\b/i
+];
+var SNAPSHOT_PRIMARY_ACTION_BUTTON_NAME_PATTERNS = [
+  /^(?:add|apply|ask|attach|choose|confirm|connect|continue|create|deploy|done|download|go|insert|launch|log in|new|next|ok|open|publish|refresh|retry|run|save|search|select|send|sign in|sign up|start|submit|upload)$/i,
+  /^(?:add|apply|ask|confirm|connect|continue|create|launch|new|open|refresh|retry|run|save|search|send|start|submit)\b/i
+];
+function getHighValueControlRole(entry) {
+  return entry.isEditable === true && (entry.role === "unknown" || entry.role === "generic") ? "textbox" : entry.role;
+}
+function isEditableControlRef(entry) {
+  if (entry.isEditable === false) {
+    return false;
+  }
+  const role = getHighValueControlRole(entry);
+  return entry.isEditable === true || role === "searchbox" || role === "textbox" || role === "combobox";
+}
+function isNamedSurfaceControlRef(entry) {
+  if (entry.name.length === 0) {
+    return false;
+  }
+  const role = getHighValueControlRole(entry);
+  if (role === "tab") {
+    return true;
+  }
+  if (role !== "button" && role !== "menuitem" && role !== "option") {
+    return false;
+  }
+  return SNAPSHOT_SURFACE_CONTROL_NAME_PATTERNS.some((pattern) => pattern.test(entry.name));
+}
+function isPrimaryActionButtonRef(entry) {
+  return getHighValueControlRole(entry) === "button" && entry.name.length > 0 && SNAPSHOT_PRIMARY_ACTION_BUTTON_NAME_PATTERNS.some((pattern) => pattern.test(entry.name));
+}
+var SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES = [
+  {
+    bucketKey: () => "editable",
+    fillTarget: SNAPSHOT_HIGH_VALUE_EDITABLE_REF_FILL_TARGET_LINES,
+    id: "editable",
+    matches: (entry) => isEditableControlRef(entry),
+    priority: 0
+  },
+  {
+    bucketKey: () => "named-surface",
+    fillTarget: SNAPSHOT_HIGH_VALUE_SURFACE_REF_FILL_TARGET_LINES,
+    id: "named-surface",
+    matches: (entry) => isNamedSurfaceControlRef(entry),
+    priority: 1
+  },
+  {
+    bucketKey: () => "primary-action",
+    fillTarget: SNAPSHOT_HIGH_VALUE_PRIMARY_ACTION_REF_FILL_TARGET_LINES,
+    id: "primary-action",
+    matches: (entry) => isPrimaryActionButtonRef(entry),
+    priority: 2
+  },
+  {
+    bucketKey: () => "named-link",
+    fillTarget: SNAPSHOT_HIGH_VALUE_NAMED_LINK_REF_FILL_TARGET_LINES,
+    id: "named-link",
+    matches: (entry) => getHighValueControlRole(entry) === "link" && isNamedActionLinkRef(entry),
+    priority: 3
+  },
+  {
+    bucketKey: (_entry, role) => role,
+    id: "role",
+    matches: () => true,
+    priority: 4
+  }
+];
+function isNamedActionLinkRef(entry) {
+  return entry.name.length > 0 && entry.name.length <= SNAPSHOT_HIGH_VALUE_LINK_NAME_MAX_LENGTH;
+}
+function isHighValueControlEntry(entry) {
+  const role = getHighValueControlRole(entry);
+  if (!SNAPSHOT_HIGH_VALUE_CONTROL_ROLES.has(role)) {
+    return false;
+  }
+  if (role === "link") {
+    return isNamedActionLinkRef(entry);
+  }
+  if (entry.isEditable === false && (role === "searchbox" || role === "textbox" || role === "combobox")) {
+    return false;
+  }
+  return entry.name.length > 0 || isEditableControlRef(entry);
+}
+function getHighValueControlCategoryRule(entry, role) {
+  return SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES.find((rule) => rule.matches(entry, role));
+}
+function classifyHighValueControlRef(entry) {
+  if (!isHighValueControlEntry(entry)) {
+    return void 0;
+  }
+  const role = getHighValueControlRole(entry);
+  const rule = getHighValueControlCategoryRule(entry, role);
+  if (!rule) {
+    return void 0;
+  }
+  return {
+    entry,
+    score: {
+      category: rule.id,
+      categoryPriority: rule.priority,
+      diversityBucketKey: `${rule.priority}:${rule.bucketKey(entry, role)}`,
+      lineIndex: entry.lineIndex ?? Number.MAX_SAFE_INTEGER,
+      namePriority: entry.name.length > 0 ? 0 : 1,
+      refId: entry.id,
+      role,
+      rolePriority: SNAPSHOT_HIGH_VALUE_CONTROL_ROLE_PRIORITY[role] ?? 50,
+      roundRobinBucketKey: `${rule.priority}:${role}`
+    }
+  };
+}
+function compareHighValueControlCandidates(left, right) {
+  const differences = [
+    left.score.categoryPriority - right.score.categoryPriority,
+    left.score.rolePriority - right.score.rolePriority,
+    left.score.namePriority - right.score.namePriority,
+    left.score.lineIndex - right.score.lineIndex
+  ];
+  return differences.find((difference) => difference !== 0 && !Number.isNaN(difference)) ?? compareRefIds(left.score.refId, right.score.refId);
+}
+var HighValueSelection = class {
+  selected = [];
+  selectedIds = /* @__PURE__ */ new Set();
+  candidates;
+  limit;
+  constructor(candidates, limit) {
+    this.candidates = candidates;
+    this.limit = limit;
+  }
+  take(candidate) {
+    this.selected.push(candidate);
+    this.selectedIds.add(candidate.entry.id);
+  }
+  takeFirstPerDiversityBucket() {
+    const seenBuckets = /* @__PURE__ */ new Set();
+    for (const candidate of this.candidates) {
+      if (this.selected.length >= this.limit) {
+        break;
+      }
+      if (!seenBuckets.has(candidate.score.diversityBucketKey)) {
+        seenBuckets.add(candidate.score.diversityBucketKey);
+        this.take(candidate);
+      }
+    }
+  }
+  topUp(category, target) {
+    let count = this.selected.filter((candidate) => candidate.score.category === category).length;
+    for (const candidate of this.candidates) {
+      if (this.selected.length >= this.limit || count >= target) {
+        break;
+      }
+      if (!this.selectedIds.has(candidate.entry.id) && candidate.score.category === category) {
+        this.take(candidate);
+        count += 1;
+      }
+    }
+  }
+  buildRemainingBuckets() {
+    const buckets = /* @__PURE__ */ new Map();
+    for (const candidate of this.candidates) {
+      if (this.selectedIds.has(candidate.entry.id)) {
+        continue;
+      }
+      const key = candidate.score.roundRobinBucketKey;
+      const bucket = buckets.get(key);
+      if (bucket) {
+        bucket.push(candidate);
+      } else {
+        buckets.set(key, [candidate]);
+      }
+    }
+    return [...buckets.values()].sort((left, right) => compareHighValueControlCandidates(left[0], right[0]));
+  }
+  fillRemaining() {
+    const buckets = this.buildRemainingBuckets();
+    let bucketIndex = 0;
+    while (this.selected.length < this.limit && buckets.some((bucket) => bucket.length > 0)) {
+      const candidate = buckets[bucketIndex % buckets.length].shift();
+      if (candidate) {
+        this.take(candidate);
+      }
+      bucketIndex += 1;
+    }
+  }
+  select() {
+    this.takeFirstPerDiversityBucket();
+    for (const rule of SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES) {
+      if (rule.fillTarget !== void 0) {
+        this.topUp(rule.id, rule.fillTarget);
+      }
+    }
+    this.fillRemaining();
+    return this.selected.map((candidate) => candidate.entry);
+  }
+};
+function selectHighValueControlEntries(entries, limit) {
+  const candidates = entries.map(classifyHighValueControlRef).filter((candidate) => candidate !== void 0).sort(compareHighValueControlCandidates);
+  return new HighValueSelection(candidates, limit).select();
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-segments.js
+var SNAPSHOT_MAX_ADDITIONAL_SECTIONS = 2;
+var SNAPSHOT_FALLBACK_PREVIEW_MAX_LINES = 12;
+var SNAPSHOT_LINE_MAX_CHARS = 140;
+var SNAPSHOT_SIGNAL_ROLES = /* @__PURE__ */ new Set([
+  "article",
+  "banner",
+  "button",
+  "checkbox",
+  "combobox",
+  "dialog",
+  "gridcell",
+  "heading",
+  "link",
+  "listitem",
+  "main",
+  "menu",
+  "menuitem",
+  "navigation",
+  "option",
+  "radio",
+  "region",
+  "row",
+  "searchbox",
+  "tab",
+  "textbox"
+]);
+var SNAPSHOT_SEGMENT_ROOT_ROLES = /* @__PURE__ */ new Set([
+  "article",
+  "dialog",
+  "heading",
+  "main",
+  "menu",
+  "region"
+]);
+var SNAPSHOT_ROLE_PRIORITY = {
+  article: 0,
+  main: 1,
+  dialog: 2,
+  menu: 3,
+  region: 4,
+  heading: 5,
+  searchbox: 6,
+  textbox: 7,
+  combobox: 8,
+  button: 9,
+  checkbox: 10,
+  radio: 11,
+  tab: 12,
+  option: 13,
+  link: 14,
+  listitem: 14,
+  row: 15,
+  gridcell: 16,
+  navigation: 17,
+  generic: 99,
+  unknown: 100
+};
+var SNAPSHOT_NOISE_NAME_PATTERNS = [
+  /^skip to /i,
+  /^ad$/i,
+  /^don't want to see ads\??$/i,
+  /keyboard shortcuts/i,
+  /\bpromoted\b/i,
+  /\bsponsored\b/i
+];
+var SNAPSHOT_CHROME_SECTION_PATTERNS = [
+  /^primary$/i,
+  /^footer$/i,
+  /^navigation$/i,
+  /\bwhat['’]?s happening\b/i,
+  /\brelevant people\b/i,
+  /\btrending\b/i,
+  /\brelated\b/i,
+  /\brecommended\b/i,
+  /\bsuggested\b/i
+];
+function getSnapshotRolePriority(role) {
+  return SNAPSHOT_ROLE_PRIORITY[role] ?? 50;
+}
+function parseSnapshotHeadingLevel(text) {
+  const level = text.match(/\blevel=(\d+)/)?.[1];
+  return level !== void 0 && level.length > 0 ? Number(level) : void 0;
+}
+function parseSnapshotLines(snapshot) {
+  return snapshot.split("\n").filter((line) => line.length > 0).map((raw, index) => {
+    const trimmed = raw.trimStart();
+    const depth = Math.floor((raw.match(/^\s*/)?.[0].length ?? 0) / 2);
+    const role = trimmed.match(/^[-*]\s+([^\s"]+)/)?.[1] ?? "unknown";
+    const name = normalizeWhitespace(trimmed.match(/"([^"]*)"/)?.[1] ?? "");
+    const ref = trimmed.match(/\bref=([^,\]\s]+)/)?.[1];
+    return {
+      depth,
+      headingLevel: parseSnapshotHeadingLevel(trimmed),
+      index,
+      name,
+      raw,
+      ref,
+      role
+    };
+  });
+}
+function isNoiseName(name) {
+  return SNAPSHOT_NOISE_NAME_PATTERNS.some((pattern) => pattern.test(name));
+}
+function isChromeSectionName(name) {
+  return SNAPSHOT_CHROME_SECTION_PATTERNS.some((pattern) => pattern.test(name));
+}
+function isNoiseSnapshotLine(line) {
+  if (line.name.length > 0 && isNoiseName(line.name)) {
+    return true;
+  }
+  const loweredRaw = line.raw.toLowerCase();
+  return loweredRaw.includes("promoted") || loweredRaw.includes("sponsored");
+}
+function isPotentialSegmentRootLine(line) {
+  if (!SNAPSHOT_SEGMENT_ROOT_ROLES.has(line.role)) {
+    return false;
+  }
+  if (isNoiseSnapshotLine(line)) {
+    return false;
+  }
+  if (line.role === "heading") {
+    return line.name.length > 0 && (line.headingLevel ?? 99) <= 3;
+  }
+  if (line.role === "region") {
+    return line.name.length > 0;
+  }
+  return true;
+}
+function getHeadingPriorityScore(level) {
+  switch (level) {
+    case 1:
+      return 40;
+    case 2:
+      return 22;
+    case 3:
+      return 12;
+    case void 0:
+      return 0;
+    default:
+      return 0;
+  }
+}
+function scoreSegment(segment) {
+  const { root } = segment;
+  const distinctRefs = new Set(segment.lines.flatMap((line) => line.ref !== void 0 && line.ref.length > 0 ? [line.ref] : [])).size;
+  let score = 0;
+  score += 120 - getSnapshotRolePriority(root.role) * 8;
+  score += Math.min(distinctRefs, 16);
+  score += Math.min(segment.lines.length, 12);
+  score -= Math.min(root.index, 60) / 3;
+  score -= root.depth * 6;
+  if (root.role === "heading") {
+    score += getHeadingPriorityScore(root.headingLevel);
+  }
+  if (root.name.length > 0) {
+    score += 10;
+  }
+  if (root.name.length <= 2) {
+    score -= 18;
+  }
+  if (isChromeSectionName(root.name)) {
+    score -= 45;
+  }
+  if (isNoiseName(root.name)) {
+    score -= 1e3;
+  }
+  return score;
+}
+function hasDuplicateSegmentAncestor(line, stack) {
+  const name = normalizeWhitespace(line.name.toLowerCase());
+  if (name.length === 0) {
+    return false;
+  }
+  for (let index = stack.length - 1; index >= 0; index -= 1) {
+    const ancestor = stack.at(index);
+    if (ancestor && normalizeWhitespace(ancestor.name.toLowerCase()) === name && SNAPSHOT_SEGMENT_ROOT_ROLES.has(ancestor.role)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildSnapshotSegments(snapshotLines) {
+  const roots = [];
+  const stack = [];
+  for (const line of snapshotLines) {
+    stack.length = line.depth;
+    if (isPotentialSegmentRootLine(line) && !hasDuplicateSegmentAncestor(line, stack)) {
+      roots.push(line);
+    }
+    stack[line.depth] = line;
+  }
+  return roots.map((root, index) => {
+    let endIndexExclusive = snapshotLines.length;
+    for (let nextIndex = index + 1; nextIndex < roots.length; nextIndex += 1) {
+      const candidate = roots[nextIndex];
+      if (candidate.depth <= root.depth) {
+        endIndexExclusive = candidate.index;
+        break;
+      }
+    }
+    const lines = snapshotLines.slice(root.index, endIndexExclusive);
+    const segment = {
+      endIndexExclusive,
+      lines,
+      root,
+      score: 0,
+      startIndex: root.index
+    };
+    return Object.assign({}, segment, { score: scoreSegment(segment) });
+  });
+}
+function choosePrimarySegment(segments) {
+  if (segments.length === 0) {
+    return void 0;
+  }
+  return segments.find((segment) => segment.root.role === "main" || segment.root.role === "article") ?? segments.find((segment) => segment.root.role === "heading" && segment.root.headingLevel === 1) ?? segments.find((segment) => segment.score >= 90) ?? [...segments].sort((left, right) => {
+    const difference = right.score - left.score;
+    return difference !== 0 && !Number.isNaN(difference) ? difference : left.startIndex - right.startIndex;
+  })[0];
+}
+function isChromePreviewSegment(segment) {
+  return isChromeSectionName(segment.root.name) || segment.root.role === "heading" && segment.root.name.length <= 2;
+}
+function chooseAdditionalSegments(segments, primary) {
+  if (!primary) {
+    return [];
+  }
+  const seenNames = /* @__PURE__ */ new Set([normalizeWhitespace(primary.root.name.toLowerCase())]);
+  const rankedCandidates = segments.filter((segment) => segment !== primary && segment.score >= 45).sort((left, right) => {
+    const leftDistance = Math.abs(left.startIndex - primary.startIndex);
+    const rightDistance = Math.abs(right.startIndex - primary.startIndex);
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.startIndex - right.startIndex;
+  });
+  const chosen = [];
+  for (const segment of rankedCandidates) {
+    if (chosen.length >= SNAPSHOT_MAX_ADDITIONAL_SECTIONS) {
+      break;
+    }
+    if (isChromePreviewSegment(segment)) {
+      continue;
+    }
+    const nameKey = normalizeWhitespace(segment.root.name.toLowerCase());
+    if (nameKey.length > 0 && seenNames.has(nameKey)) {
+      continue;
+    }
+    chosen.push(segment);
+    if (nameKey.length > 0) {
+      seenNames.add(nameKey);
+    }
+  }
+  return chosen.sort((left, right) => left.startIndex - right.startIndex);
+}
+function getMeaningfulSegmentLines(segment) {
+  return segment.lines.filter((line) => {
+    if (isNoiseSnapshotLine(line)) {
+      return false;
+    }
+    if (line.role === "generic" && (line.ref ?? "") === "" && line.name.length === 0) {
+      return false;
+    }
+    if (line.role === "link" && line.name.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+function formatPreviewLine(line, baseDepth) {
+  const leadingWhitespace = (line.raw.match(/^\s*/) ?? [""])[0].length;
+  const stripChars = Math.min(leadingWhitespace, Math.max(0, baseDepth) * 2);
+  return truncateText(line.raw.slice(stripChars), SNAPSHOT_LINE_MAX_CHARS);
+}
+function isRedundantPreviewLine(line, root) {
+  if (line === root) {
+    return false;
+  }
+  return root.role !== "heading" && line.depth - root.depth > 2 || root.name.length > 0 && line.name === root.name && (line.role === "heading" || line.role === "link");
+}
+function buildSegmentPreview(segment, maxLines) {
+  const meaningfulLines = getMeaningfulSegmentLines(segment);
+  if (meaningfulLines.length === 0) {
+    return { omittedCount: 0, refIds: [], lines: [] };
+  }
+  const previewLines = [];
+  const previewRefIds = /* @__PURE__ */ new Set();
+  const seenPreviewKeys = /* @__PURE__ */ new Set();
+  const rootDepth = segment.root.depth;
+  for (const line of meaningfulLines) {
+    if (previewLines.length >= maxLines) {
+      break;
+    }
+    if (isRedundantPreviewLine(line, segment.root)) {
+      continue;
+    }
+    const key = `${line.role}:${line.name}:${line.ref ?? ""}:${line.depth}`;
+    if (seenPreviewKeys.has(key)) {
+      continue;
+    }
+    seenPreviewKeys.add(key);
+    previewLines.push(line);
+    if (line.ref !== void 0 && line.ref.length > 0) {
+      previewRefIds.add(line.ref);
+    }
+  }
+  return {
+    omittedCount: Math.max(0, meaningfulLines.length - previewLines.length),
+    refIds: [...previewRefIds],
+    lines: previewLines.map((line) => formatPreviewLine(line, rootDepth))
+  };
+}
+function hasSnapshotSignal(line) {
+  return SNAPSHOT_SIGNAL_ROLES.has(line.role) || (line.ref ?? "").length > 0 || line.name.length > 0;
+}
+function buildFallbackSnapshotOutline(snapshotLines) {
+  const selected = /* @__PURE__ */ new Set();
+  for (let index = 0; index < snapshotLines.length && selected.size < 4; index += 1) {
+    if (!isNoiseSnapshotLine(snapshotLines[index])) {
+      selected.add(index);
+    }
+  }
+  for (let index = 0; index < snapshotLines.length && selected.size < SNAPSHOT_FALLBACK_PREVIEW_MAX_LINES; index += 1) {
+    const line = snapshotLines[index];
+    if (isNoiseSnapshotLine(line)) {
+      continue;
+    }
+    if (hasSnapshotSignal(line)) {
+      selected.add(index);
+    }
+  }
+  const chosenLines = [...selected].sort((left, right) => left - right).slice(0, SNAPSHOT_FALLBACK_PREVIEW_MAX_LINES).map((index) => snapshotLines[index]);
+  return {
+    omittedCount: Math.max(0, snapshotLines.length - chosenLines.length),
+    refIds: chosenLines.flatMap((line) => line.ref !== void 0 && line.ref.length > 0 ? [line.ref] : []),
+    lines: chosenLines.map((line) => truncateText(line.raw, SNAPSHOT_LINE_MAX_CHARS))
+  };
+}
+function buildRefLineOrderMap(snapshotLines) {
+  const map = /* @__PURE__ */ new Map();
+  for (const line of snapshotLines) {
+    if (line.ref === void 0 || line.ref.length === 0 || map.has(line.ref)) {
+      continue;
+    }
+    map.set(line.ref, line.index);
+  }
+  return map;
+}
+function canUseStructuredSnapshotPreview(snapshotLines, refEntries) {
+  if (snapshotLines.length === 0) {
+    return false;
+  }
+  const linesWithRecognizedRoles = snapshotLines.filter((line) => line.role !== "unknown").length;
+  const linesWithNames = snapshotLines.filter((line) => line.name.length > 0).length;
+  const parsedRefIds = new Set(snapshotLines.flatMap((line) => line.ref !== void 0 && line.ref.length > 0 ? [line.ref] : []));
+  return linesWithRecognizedRoles >= Math.min(snapshotLines.length, 3) || linesWithNames >= Math.min(snapshotLines.length, 3) || parsedRefIds.size >= Math.min(refEntries.length, 3);
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-compact.js
+var PRIMARY_PREVIEW_LINES = 8;
+var SECTION_PREVIEW_LINES = 2;
+var KEY_REF_MAX_LINES = 8;
+var OTHER_REF_MAX_LINES = 4;
+var HIGH_VALUE_REF_MAX_LINES = 10;
+function getSnapshotRoleCounts(entries) {
+  const counts = {};
+  for (const entry of entries) {
+    counts[entry.role] = (counts[entry.role] ?? 0) + 1;
+  }
+  return counts;
+}
+function formatRoleCounts(counts) {
+  const entries = Object.entries(counts);
+  if (entries.length === 0) {
+    return void 0;
+  }
+  const ordered = entries.sort((left, right) => right[1] !== left[1] ? right[1] - left[1] : getSnapshotRolePriority(left[0]) - getSnapshotRolePriority(right[0]));
+  const visible = ordered.slice(0, 4).map(([role, count]) => `${role} ${count}`);
+  const omitted = Math.max(0, ordered.length - visible.length);
+  if (omitted > 0) {
+    visible.push(`+${omitted} more`);
+  }
+  return visible.join(", ");
+}
+function rankRefEntries(entries, preview, focus, lines) {
+  const previewIds = new Set(preview);
+  const focusIds = new Set(focus);
+  const order = buildRefLineOrderMap(lines);
+  const refBucket = (id) => {
+    if (previewIds.has(id)) {
+      return 0;
+    }
+    return focusIds.has(id) ? 1 : 2;
+  };
+  return [...entries].sort((left, right) => {
+    const bucketDifference = refBucket(left.id) - refBucket(right.id);
+    if (bucketDifference !== 0) {
+      return bucketDifference;
+    }
+    const roleDifference = getSnapshotRolePriority(left.role) - getSnapshotRolePriority(right.role);
+    if (roleDifference !== 0) {
+      return roleDifference;
+    }
+    const nameDifference = Number(left.name.length === 0) - Number(right.name.length === 0);
+    if (nameDifference !== 0) {
+      return nameDifference;
+    }
+    const lineDifference = (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER);
+    return lineDifference !== 0 ? lineDifference : compareRefIds(left.id, right.id);
+  });
+}
+function getFallbackPreview(lines, structured, primary) {
+  return !structured || !primary || primary.lines.length === 0 ? buildFallbackSnapshotOutline(lines) : void 0;
+}
+function buildPagePreview(lines, entries) {
+  const useStructured = canUseStructuredSnapshotPreview(lines, entries);
+  const segments = useStructured ? buildSnapshotSegments(lines) : [];
+  const primarySegment = useStructured ? choosePrimarySegment(segments) : void 0;
+  const additionalSegments = useStructured ? chooseAdditionalSegments(segments, primarySegment) : [];
+  const additionalSegmentCount = primarySegment ? Math.max(0, segments.length - 1) : 0;
+  const primaryPreview = primarySegment ? buildSegmentPreview(primarySegment, PRIMARY_PREVIEW_LINES) : void 0;
+  return {
+    useStructured,
+    primarySegment,
+    primaryPreview,
+    additionalSegments,
+    additionalPreviews: additionalSegments.map((segment) => ({ segment, preview: buildSegmentPreview(segment, SECTION_PREVIEW_LINES) })).filter(({ preview }) => preview.lines.length > 0),
+    fallbackPreview: getFallbackPreview(lines, useStructured, primaryPreview),
+    omittedAdditionalSectionCount: Math.max(0, additionalSegmentCount - additionalSegments.length)
+  };
+}
+function getPreviewRefIds(page) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...page.primaryPreview?.refIds ?? [],
+      ...page.additionalPreviews.flatMap(({ preview }) => preview.refIds),
+      ...page.fallbackPreview?.refIds ?? []
+    ])
+  ];
+}
+function getFocusRefIds(page) {
+  const primary = page.useStructured && page.primarySegment ? getMeaningfulSegmentLines(page.primarySegment) : [];
+  const additional = page.useStructured ? page.additionalSegments.flatMap(getMeaningfulSegmentLines) : [];
+  return [
+    ...new Set([...primary, ...additional].flatMap((line) => line.ref !== void 0 && line.ref.length > 0 ? [line.ref] : []).concat(page.fallbackPreview?.refIds ?? []))
+  ];
+}
+function selectCompactRefs(entries) {
+  const visible = entries.filter((entry) => !isNoiseName(entry.name) && !isChromeSectionName(entry.name) && !(entry.role === "heading" && entry.name.length <= 2));
+  const key = visible.slice(0, KEY_REF_MAX_LINES);
+  const keyIds = new Set(key.map((entry) => entry.id));
+  const other = visible.filter((entry) => !keyIds.has(entry.id)).slice(0, OTHER_REF_MAX_LINES);
+  const displayedIds = new Set([...key, ...other].map((entry) => entry.id));
+  const omitted = visible.filter((entry) => !displayedIds.has(entry.id));
+  const highValueCandidates = omitted.filter((entry) => isHighValueControlEntry(entry) && !isNoiseName(entry.name) && !isChromeSectionName(entry.name));
+  const highValue = selectHighValueControlEntries(highValueCandidates, HIGH_VALUE_REF_MAX_LINES);
+  return {
+    key,
+    other,
+    highValue,
+    omittedHighValueControls: Math.max(0, highValueCandidates.length - highValue.length),
+    omittedNonHighlightedRefs: Math.max(0, omitted.length - highValueCandidates.length)
+  };
+}
+function formatCompactRef(entry) {
+  const suffix = entry.name.length > 0 ? ` "${truncateText(entry.name, 96)}"` : "";
+  return `- ${entry.id} ${entry.role}${suffix}`;
+}
+function formatAdditionalPreviews(page) {
+  if (page.additionalPreviews.length === 0) {
+    return [];
+  }
+  const lines = ["", "Additional sections:"];
+  page.additionalPreviews.forEach(({ preview }, index) => {
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(...preview.lines);
+    if (preview.omittedCount > 0) {
+      lines.push(`- ... (${preview.omittedCount} more lines in this section)`);
+    }
+  });
+  if (page.omittedAdditionalSectionCount > 0) {
+    lines.push(`- ... (${page.omittedAdditionalSectionCount} more sections omitted)`);
+  }
+  return lines;
+}
+function formatFallbackPreview(preview, fullOutputPath) {
+  const lines = [
+    "",
+    "Compact outline:",
+    ...preview.lines.length > 0 ? preview.lines : ["(no interactive elements)"]
+  ];
+  if (preview.omittedCount > 0) {
+    const source = fullOutputPath !== void 0 && fullOutputPath.length > 0 ? `full output path: ${fullOutputPath}` : "the full redacted snapshot was omitted";
+    lines.push(`- ... (${preview.omittedCount} additional snapshot lines omitted; ${source})`);
+  }
+  return lines;
+}
+function formatPagePreview(page, fullOutputPath) {
+  if (page.fallbackPreview) {
+    return formatFallbackPreview(page.fallbackPreview, fullOutputPath);
+  }
+  const lines = [
+    "",
+    "Primary content:",
+    ...page.primaryPreview?.lines ?? ["(no interactive elements)"]
+  ];
+  if ((page.primaryPreview?.omittedCount ?? 0) > 0) {
+    lines.push(`- ... (${page.primaryPreview?.omittedCount ?? "undefined"} more lines in this section)`);
+  }
+  return [...lines, ...formatAdditionalPreviews(page)];
+}
+function formatRefSelection(selection) {
+  const lines = [
+    "",
+    "Key refs:",
+    ...selection.key.length > 0 ? selection.key.map(formatCompactRef) : ["(no refs)"]
+  ];
+  if (selection.other.length > 0) {
+    lines.push("", "Other refs:", ...selection.other.map(formatCompactRef));
+  }
+  if (selection.omittedNonHighlightedRefs > 0) {
+    lines.push(`- ... (${selection.omittedNonHighlightedRefs} additional refs omitted)`);
+  }
+  if (selection.highValue.length > 0) {
+    lines.push("", "Omitted high-value controls:", ...selection.highValue.map(formatCompactRef));
+    if (selection.omittedHighValueControls > 0) {
+      lines.push(`- ... (${selection.omittedHighValueControls} additional high-value controls omitted)`);
+    }
+  }
+  return lines;
+}
+function getPreviewSections(page) {
+  const primary = page.primarySegment ? [
+    {
+      linesShown: page.primaryPreview?.lines.length ?? 0,
+      omittedLines: page.primaryPreview?.omittedCount ?? 0,
+      role: page.primarySegment.root.role,
+      title: page.primarySegment.root.name
+    }
+  ] : [];
+  return [
+    ...primary,
+    ...page.additionalPreviews.map(({ preview, segment }) => ({
+      linesShown: preview.lines.length,
+      omittedLines: preview.omittedCount,
+      role: segment.root.role,
+      title: segment.root.name
+    }))
+  ];
+}
+function buildCompactSnapshotView(data, fullOutputPath, spillErrorText) {
+  const snapshot = getSnapshotText(data) ?? "(no interactive elements)";
+  const snapshotLines = parseSnapshotLines(snapshot);
+  const refEntries = enrichSnapshotRefEntries(getSnapshotRefEntries(data), snapshotLines);
+  const roleCounts = getSnapshotRoleCounts(refEntries);
+  const roleCountsText = formatRoleCounts(roleCounts);
+  const page = buildPagePreview(snapshotLines, refEntries);
+  const previewRefIds = getPreviewRefIds(page);
+  const ranked = rankRefEntries(refEntries, previewRefIds, getFocusRefIds(page), page.useStructured ? snapshotLines : []);
+  const refs = selectCompactRefs(ranked);
+  const origin = getSnapshotOrigin(data);
+  const lines = [
+    `Origin: ${origin}`,
+    `Refs: ${refEntries.length}`,
+    ...roleCountsText !== void 0 ? [`Top roles: ${roleCountsText}`] : [],
+    "",
+    "Compact snapshot view.",
+    "Viewport note: compact snapshots are DOM/signal-prioritized, not guaranteed to start with the currently scrolled viewport; use the full redacted snapshot, a screenshot, or listed high-value refs when viewport context matters.",
+    ...formatPagePreview(page, fullOutputPath),
+    ...formatRefSelection(refs),
+    "",
+    fullOutputPath !== void 0 && fullOutputPath.length > 0 ? `Full redacted snapshot path: ${fullOutputPath}` : `Full redacted snapshot unavailable: ${spillErrorText ?? "temp spill file could not be created."}`
+  ];
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    data: {
+      compacted: true,
+      fullOutputPath,
+      origin,
+      previewMode: page.fallbackPreview ? "outline" : "structured",
+      viewportOrdering: "dom-signal-prioritized",
+      spillError: spillErrorText,
+      previewRefIds,
+      highValueControlRefIds: refs.highValue.map((entry) => entry.id),
+      additionalSectionsOmitted: page.omittedAdditionalSectionCount,
+      previewSections: getPreviewSections(page),
+      refCount: refEntries.length,
+      roleCounts,
+      snapshotLineCount: countLines(snapshot),
+      structuredPreviewUsed: !page.fallbackPreview
+    }
+  };
+}
+
+// dist/extensions/agent-browser/lib/command-capabilities.js
+var ADDITIONAL_COMMAND_TOKENS = [
+  "a11y",
+  "auth",
+  "chat",
+  "clipboard",
+  "confirm",
+  "connect",
+  "dashboard",
+  "deny",
+  "device",
+  "dialog",
+  "diff",
+  "doctor",
+  "errors",
+  "eval",
+  "find",
+  "frame",
+  "get",
+  "highlight",
+  "inspect",
+  "install",
+  "is",
+  "mcp",
+  "plugin",
+  "plugins",
+  "profiles",
+  "profiler",
+  "react",
+  "record",
+  "removeinitscript",
+  "session",
+  "set",
+  "skills",
+  "snapshot",
+  "state",
+  "stream",
+  "trace",
+  "upgrade",
+  "vitals",
+  "wait",
+  "web-vitals",
+  "webmcp",
+  "window"
+];
+var COMMAND_CAPABILITIES = [
+  {
+    command: "back",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "batch",
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "check",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "click",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["quit", "exit"],
+    closesSession: true,
+    command: "close",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "console",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "cookies",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "dblclick",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "dialog",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "diff",
+    guardsPageRefs: true
+  },
+  {
+    command: "download",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "drag",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "errors",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "eval",
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "fill",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "find",
+    eligibleForElectronHealthProbe: true
+  },
+  {
+    command: "frame",
+    guardsPageRefs: true
+  },
+  {
+    command: "focus",
+    guardsPageRefs: true
+  },
+  {
+    command: "forward",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "get",
+    guardsPageRefs: true
+  },
+  {
+    command: "highlight",
+    guardsPageRefs: true
+  },
+  {
+    command: "hover",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "is",
+    guardsPageRefs: true
+  },
+  {
+    command: "keydown",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyboard",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyup",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "mouse",
+    eligibleForElectronHealthProbe: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "network",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    aliases: ["goto", "navigate"],
+    command: "open",
+    eligibleForPageChangeSummary: true,
+    excludedFromPinning: true,
+    invalidatesBatchRefs: true,
+    openNavigation: true
+  },
+  {
+    command: "pdf",
+    eligibleForPageChangeSummary: true
+  },
+  {
+    aliases: ["key"],
+    command: "press",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "pushstate",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "reload",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "read",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "screenshot",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "scroll",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["scrollinto"],
+    command: "scrollintoview",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "select",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "session",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "storage",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "swipe",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "tab",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "tap",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "type",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "uncheck",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "upload",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  }
+];
+var COMMAND_CAPABILITY_BY_NAME = /* @__PURE__ */ new Map();
+for (const entry of COMMAND_CAPABILITIES) {
+  COMMAND_CAPABILITY_BY_NAME.set(entry.command, entry);
+  for (const alias of entry.aliases ?? []) {
+    COMMAND_CAPABILITY_BY_NAME.set(alias, entry);
+  }
+}
+var KNOWN_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  ...COMMAND_CAPABILITY_BY_NAME.keys(),
+  ...ADDITIONAL_COMMAND_TOKENS
+]);
+
+// dist/extensions/agent-browser/lib/session-identity.js
+var SESSION_COMPONENT_ALPHANUMERIC = /^[\p{Alphabetic}\p{Number}]$/u;
+function canonicalizeAgentBrowserNamespace(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  let normalized = "";
+  let lastWasSeparator = false;
+  for (const character of value) {
+    if (SESSION_COMPONENT_ALPHANUMERIC.test(character)) {
+      normalized += character.toLowerCase();
+      lastWasSeparator = false;
+      continue;
+    }
+    if (normalized.length > 0 && !lastWasSeparator) {
+      normalized += character === "_" ? "_" : "-";
+      lastWasSeparator = true;
+    }
+  }
+  const result = normalized.replace(/[-_]+$/u, "");
+  return result.length > 0 ? result : void 0;
+}
+function foldAgentBrowserFilesystemIdentity(value, platform) {
+  if (platform !== "darwin" && platform !== "win32") {
+    return value;
+  }
+  return value.normalize("NFC").toLowerCase().toUpperCase().toLowerCase().normalize("NFC");
+}
+function getAgentBrowserSessionIdentityKey(sessionName, namespace, platform = process.platform) {
+  const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
+  const canonicalSessionName = foldAgentBrowserFilesystemIdentity(sessionName, platform);
+  return canonicalNamespace !== void 0 ? `${foldAgentBrowserFilesystemIdentity(canonicalNamespace, platform)}\0${canonicalSessionName}` : canonicalSessionName;
+}
+
+// dist/extensions/agent-browser/lib/argv-grammar.js
+var GLOBAL_VALUE_FLAGS = [
+  "--session",
+  "--namespace",
+  "--cdp",
+  "--config",
+  "--profile",
+  "--session-name",
+  "--restore-save",
+  "--restore-check-url",
+  "--restore-check-text",
+  "--restore-check-fn",
+  "--proxy",
+  "--proxy-bypass",
+  "--ca-cert",
+  "--headers",
+  "--executable-path",
+  "--extension",
+  "--init-script",
+  "--enable",
+  "--provider",
+  "-p",
+  "--engine",
+  "--state",
+  "--download-path",
+  "--screenshot-dir",
+  "--screenshot-format",
+  "--screenshot-quality",
+  "--color-scheme",
+  "--device",
+  "--args",
+  "--user-agent",
+  "--allowed-domains",
+  "--action-policy",
+  "--confirm-actions",
+  "--max-output",
+  "--model",
+  "--idle-timeout",
+  "--input-mode"
+];
+var COMMAND_VALUE_FLAGS = [
+  "--allowed-origins",
+  "--baseline",
+  "--body",
+  "--categories",
+  "--content",
+  "--curl",
+  "--depth",
+  "-d",
+  "--domain",
+  "--expires",
+  "--filter",
+  "--frame",
+  "--fn",
+  "--label",
+  "--load",
+  "--method",
+  "--name",
+  "--older-than",
+  "--output",
+  "--prefix",
+  "--path",
+  "--port",
+  "--params",
+  "--resource-type",
+  "--resource-types",
+  "--sameSite",
+  "--scope",
+  "--selector",
+  "-s",
+  "--status",
+  "--tags",
+  "--text",
+  "--threshold",
+  "--timeout",
+  "--type",
+  "--url",
+  "--username",
+  "--password",
+  "--wait-until"
+];
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  ...GLOBAL_VALUE_FLAGS,
+  ...COMMAND_VALUE_FLAGS
+]);
+var PREVALIDATED_VALUE_FLAGS = new Set(GLOBAL_VALUE_FLAGS);
+
+// dist/extensions/agent-browser/lib/redaction-fields.js
+var SENSITIVE_FIELD_NAME_PATTERN = /^(?:[A-Za-z0-9_-]*(?:api[_-]?key|access[_-]?key|private[_-]?key|secret(?:[_-]?(?:key|access[_-]?key))?|token|password|passwd|credentials?|database[_-]?url|db[_-]?url|connection[_-]?string|mongo(?:db)?[_-]?uri|redis[_-]?url)|[A-Za-z0-9]*(?:apiKey|ApiKey|apikey|privateKey|PrivateKey|databaseUrl|DatabaseUrl|dbUrl|DbUrl|connectionString|ConnectionString|mongoUri|MongoUri|mongodbUri|MongodbUri|mongoDbUri|MongoDbUri|redisUrl|RedisUrl|Token|Secret|Password|Credential|Credentials)|auth(?:orization)?|bearer|client(?:_|-)?secret|cookie|id(?:_|-)?token|pass(?:word)?|proxy(?:_|-)?authorization|refresh(?:_|-)?token|sentry(?:_|-)?key|session(?:_|-)?id|set(?:_|-)?cookie|sig(?:nature)?|write(?:_|-)?key|x(?:_|-)?api(?:_|-)?key)$/i;
+var ENV_SECRET_ASSIGNMENT_PATTERN = /\b((?:export\s+)?([A-Za-z_][A-Za-z0-9_-]*)(\s*[:=]\s*))(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;]+)/g;
+function isSensitiveFieldName(key) {
+  SENSITIVE_FIELD_NAME_PATTERN.lastIndex = 0;
+  return SENSITIVE_FIELD_NAME_PATTERN.test(key);
+}
+function isEnvSecretAssignmentKey(key) {
+  if (!isSensitiveFieldName(key)) {
+    return false;
+  }
+  if (key === "password" || key.includes("_") || key.includes("-") || key === key.toUpperCase()) {
+    return true;
+  }
+  return /(?:apiKey|ApiKey|privateKey|PrivateKey|databaseUrl|DatabaseUrl|dbUrl|DbUrl|connectionString|ConnectionString|mongoUri|MongoUri|mongodbUri|MongodbUri|mongoDbUri|MongoDbUri|redisUrl|RedisUrl|Token|Secret|Password|Credential|Credentials)$/.test(key);
+}
+function isLineBoundary(text, index) {
+  return index < 0 || index >= text.length || text[index] === "\n" || text[index] === "\r";
+}
+function redactPasswordAssignment(text, match, prefix, offset) {
+  const end = offset + match.length;
+  if (!isLineBoundary(text, offset - 1) || !isLineBoundary(text, end) || /^(?:\[REDACTED\]|%5Bredacted%5D)/i.test(match.slice(prefix.length))) {
+    return match;
+  }
+  const value = match.slice(prefix.length);
+  const boundary = value[0] === '"' || value[0] === "'" ? -1 : value.search(/[&#](?=[A-Za-z_][A-Za-z0-9_-]*\s*=)/);
+  return `${prefix}[REDACTED]${boundary < 0 ? "" : value.slice(boundary)}`;
+}
+function redactEnvSecretAssignments(text) {
+  return text.replace(
+    ENV_SECRET_ASSIGNMENT_PATTERN,
+    // String.replace supplies match, three captures, then the source offset.
+    (match, prefix, key, _separator, offset) => {
+      if (!isEnvSecretAssignmentKey(key)) {
+        return match;
+      }
+      return key === "password" ? redactPasswordAssignment(text, match, prefix, offset) : `${prefix}[REDACTED]`;
+    }
+  );
+}
+function credentialTrailingPunctuation(credential) {
+  return credential.match(/[,.:;!?]+$/)?.[0] ?? "";
+}
+function formatRedactedCredential(label, credential, trailing = "") {
+  return `${label} [REDACTED]${credentialTrailingPunctuation(credential)}${trailing}`;
+}
+function redactBearerCredentials(text) {
+  return text.replace(
+    /((?:\b([A-Za-z][A-Za-z0-9_-]*)\s*[:=]\s*|(?:^|\s)(?:-H\s*|--header(?:\s+|=)))["']?Bearer)\s+([^\s"',)[\]]+)([),.]?)/gi,
+    // String.replace supplies the match followed by this expression's four captures.
+    (match, label, field, credential, trailing) => {
+      if (field !== void 0 && field.length > 0 && !isSensitiveFieldName(field)) {
+        return match;
+      }
+      return formatRedactedCredential(label, credential, trailing);
+    }
+  ).replace(/\b(Bearer)\s+([^\s\\"',)[\]]+)([),.]?)/gi, (match, label, credential, trailing) => {
+    const token = credential.slice(0, credential.length - credentialTrailingPunctuation(credential).length);
+    if (!/^[A-Za-z0-9._~+/-]+=*$/.test(token) || !/[0-9._~+/=-]/.test(token)) {
+      return match;
+    }
+    return formatRedactedCredential(label, credential, trailing);
+  });
+}
+function redactStandaloneBasicCredential(text) {
+  return text.replace(/\b(Basic)\s+([A-Za-z0-9+/=]{12,})/gi, (match, label, credential) => {
+    if (!/[0-9+/=]/.test(credential)) {
+      return match;
+    }
+    return `${label} [REDACTED]`;
+  });
+}
+
+// dist/extensions/agent-browser/lib/redaction-json.js
+function nextQuotePosition(options) {
+  if (options.char === '"') {
+    return options.index;
+  }
+  return options.char === "\\" ? options.quoteAfterNext : options.quoteAtNext;
+}
+function buildJsonBoundaries(text) {
+  const boundaries = new Int32Array(text.length + 1).fill(-1);
+  let quoteAtNext = -1;
+  let quoteAfterNext = -1;
+  for (let index = text.length - 1; index >= 0; index -= 1) {
+    const char = text[index];
+    switch (char) {
+      case "}":
+      case "]":
+        boundaries[index] = index;
+        break;
+      case '"':
+        boundaries[index] = quoteAtNext < 0 ? -1 : boundaries[quoteAtNext + 1];
+        break;
+      case "{":
+      case "[": {
+        const end = boundaries[index + 1];
+        boundaries[index] = end >= 0 && text[end] === (char === "{" ? "}" : "]") ? boundaries[end + 1] : -1;
+        break;
+      }
+      default:
+        boundaries[index] = boundaries[index + 1];
+    }
+    const quote = nextQuotePosition({ char, index, quoteAtNext, quoteAfterNext });
+    quoteAfterNext = quoteAtNext;
+    quoteAtNext = quote;
+  }
+  return boundaries;
+}
+function createBalancedJsonEndFinder(text) {
+  let boundaries;
+  return (startIndex) => {
+    const opener = text[startIndex];
+    if (opener !== "{" && opener !== "[") {
+      return;
+    }
+    boundaries ??= buildJsonBoundaries(text);
+    const end = boundaries[startIndex + 1];
+    return end >= 0 && text[end] === (opener === "{" ? "}" : "]") ? end : void 0;
+  };
+}
+function parseJsonString(token) {
+  const value = JSON.parse(token);
+  if (typeof value !== "string") {
+    throw new Error("Expected a JSON string token");
+  }
+  return value;
+}
+function isSerializedJson(text) {
+  if (text === "[REDACTED]" || !/^\s*[[{"\d\-tfn]/.test(text)) {
+    return false;
+  }
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findJsonValueEnd(text, start, findEnd) {
+  const balancedEnd = findEnd(start);
+  if (balancedEnd !== void 0) {
+    return balancedEnd + 1;
+  }
+  if (text[start] === '"') {
+    const strings = /"(?:\\.|[^"\\])*"/g;
+    strings.lastIndex = start;
+    const fieldValue = strings.exec(text);
+    if (fieldValue === null) {
+      throw new Error("Expected a validated JSON string field value");
+    }
+    return parseJsonString(fieldValue[0]) === "[REDACTED]" ? void 0 : strings.lastIndex;
+  }
+  let end = start;
+  while (end < text.length && !/[\s,\]}]/.test(text[end])) {
+    end += 1;
+  }
+  return end;
+}
+function redactSerializedJson(text, redact) {
+  if (!isSerializedJson(text)) {
+    return;
+  }
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text);
+  const strings = /"(?:\\.|[^"\\])*"/g;
+  let match;
+  while ((match = strings.exec(text)) !== null) {
+    const end = strings.lastIndex;
+    const value = parseJsonString(match[0]);
+    const redacted = redact(value);
+    if (redacted !== value) {
+      output += text.slice(cursor, match.index) + JSON.stringify(redacted);
+      cursor = end;
+    }
+    const separator = /^\s*:\s*/.exec(text.slice(end));
+    if (separator === null || !isSensitiveFieldName(value)) {
+      continue;
+    }
+    const valueStart = end + separator[0].length;
+    const valueEnd = findJsonValueEnd(text, valueStart, findEnd);
+    if (valueEnd === void 0) {
+      strings.lastIndex = valueStart;
+      strings.exec(text);
+      continue;
+    }
+    output += text.slice(cursor, valueStart) + '"[REDACTED]"';
+    cursor = valueEnd;
+    strings.lastIndex = valueEnd;
+  }
+  return output + text.slice(cursor);
+}
+function redactEmbeddedStructuredText(text, redact) {
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text);
+  const openers = /[[{]/g;
+  let match;
+  while ((match = openers.exec(text)) !== null) {
+    const endIndex = findEnd(match.index);
+    if (endIndex === void 0) {
+      continue;
+    }
+    const candidate = text.slice(match.index, endIndex + 1);
+    const redacted = redactSerializedJson(candidate, redact) ?? candidate;
+    if (redacted !== candidate) {
+      output += text.slice(cursor, match.index) + redacted;
+      cursor = endIndex + 1;
+    }
+    openers.lastIndex = endIndex + 1;
+  }
+  return cursor === 0 ? text : output + text.slice(cursor);
+}
+
+// dist/extensions/agent-browser/lib/redaction-url.js
+var SENSITIVE_QUERY_PARAM_PATTERN = /^(?:access(?:_|-)?token|api(?:_|-)?key|auth|authorization|authorization(?:_|-)?session(?:_|-)?id|bearer|client(?:_|-)?secret|code|cookie|id(?:_|-)?token|key|pass(?:word)?|refresh(?:_|-)?token|relay(?:_|-)?state|saml(?:_|-)?request|saml(?:_|-)?response|secret|sentry(?:_|-)?key|session(?:_|-)?id|sig(?:nature)?|token|write(?:_|-)?key)$/i;
+var AUTH_STATE_QUERY_PARAM_PATTERN = /^(?:nonce|state)$/i;
+var AUTH_URL_CONTEXT_PATTERN = /(?:^|[./_-])(?:auth|authorize|callback|login|oauth2?|oidc|saml|sso)(?:[./?#_-]|$)/i;
+function shouldRedactQueryParam(name) {
+  return SENSITIVE_QUERY_PARAM_PATTERN.test(name) || isSensitiveFieldName(name);
+}
+function isSensitiveParameter(name, authContext) {
+  return shouldRedactQueryParam(name) || authContext && AUTH_STATE_QUERY_PARAM_PATTERN.test(name);
+}
+function redactParameters(params, authContext) {
+  let mutated = false;
+  for (const [name] of params) {
+    if (isSensitiveParameter(name, authContext)) {
+      params.set(name, "[REDACTED]");
+      mutated = true;
+    }
+  }
+  return mutated;
+}
+function getHashParameters(hash) {
+  const text = hash.startsWith("#") ? hash.slice(1) : hash;
+  return text.includes("=") ? new URLSearchParams(text) : void 0;
+}
+function redactUrlToken(token) {
+  let parsed;
+  try {
+    parsed = new URL(token);
+  } catch {
+    return token;
+  }
+  const originalHref = parsed.href;
+  if (parsed.username.length > 0) {
+    parsed.username = "[REDACTED]";
+  }
+  if (parsed.password.length > 0) {
+    parsed.password = "[REDACTED]";
+  }
+  const hashParams = getHashParameters(parsed.hash);
+  const authContext = AUTH_URL_CONTEXT_PATTERN.test(`${parsed.hostname}${parsed.pathname}`) || [...parsed.searchParams.keys(), ...hashParams?.keys() ?? []].some(shouldRedactQueryParam);
+  redactParameters(parsed.searchParams, authContext);
+  if (hashParams && redactParameters(hashParams, authContext)) {
+    parsed.hash = `#${hashParams.toString()}`;
+  }
+  return parsed.href === originalHref ? token : parsed.href;
+}
+function decodeParameterName(raw) {
+  try {
+    return decodeURIComponent(raw.replace(/\+/g, " "));
+  } catch {
+    return raw;
+  }
+}
+function redactLooseUrlParameterText(text) {
+  return text.replace(/(?<![^\s"'`<>\])}])[^\s"'`<>\])}]*[?#&][^\s"'`<>\])}]*/g, (token) => {
+    const queryNames = [...token.matchAll(/[?#&]([^=&#\s"'`<>\])}]+)=/g)].map((match) => decodeParameterName(match[1]));
+    const authContext = AUTH_URL_CONTEXT_PATTERN.test(token) || queryNames.some(shouldRedactQueryParam);
+    return token.replace(/([?#&])([^=&#\s"'`<>\])}]+)=([^&#\s"'`<>\])}]*)/g, (match, separator, rawName, rawValue) => {
+      if (rawValue === "[REDACTED" || rawValue === "[REDACTED]" || /%5Bredacted%5D/i.test(rawValue)) {
+        return match;
+      }
+      if (!isSensitiveParameter(decodeParameterName(rawName), authContext)) {
+        return match;
+      }
+      return `${separator}${rawName}=[REDACTED]`;
+    });
+  });
+}
+function redactLooseUrlUserinfo(text) {
+  return text.replace(/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^\s"'`/@]+)@([^\s"'`]+)/g, (match, prefix, userinfo, suffix) => {
+    if (/%5Bredacted%5D/i.test(userinfo)) {
+      return match;
+    }
+    if (userinfo.includes("[REDACTED]")) {
+      return redactLooseUrlParameterText(match);
+    }
+    return redactLooseUrlParameterText(`${prefix}${userinfo.includes(":") ? "[REDACTED]:[REDACTED]" : "[REDACTED]"}@${suffix}`);
+  });
+}
+function redactLooseUrls(text) {
+  const urls = text.replace(/\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s"'`<>\])]+/g, (match) => redactUrlToken(match));
+  return redactLooseUrlParameterText(redactLooseUrlUserinfo(urls));
+}
+
+// dist/extensions/agent-browser/lib/runtime-redaction.js
+function redactSensitiveText(text) {
+  const serialized = redactSerializedJson(text, redactSensitiveText);
+  if (serialized !== void 0) {
+    return serialized;
+  }
+  const embedded = redactEmbeddedStructuredText(text, redactSensitiveText);
+  const credentials = redactStandaloneBasicCredential(redactBearerCredentials(redactLooseUrls(embedded))).replace(/\b(Authorization\s*:\s*Basic)\s+[^\s",]+/gi, "$1 [REDACTED]").replace(/\b(Cookie|Set-Cookie)\s*:\s*[^\n\r"]+/gi, "$1: [REDACTED]");
+  return redactEmbeddedStructuredText(redactEnvSecretAssignments(credentials), redactSensitiveText);
+}
+function redactSensitiveValue(value) {
+  if (typeof value === "string") {
+    return redactSensitiveText(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSensitiveValue(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+    key,
+    isSensitiveFieldName(key) ? "[REDACTED]" : redactSensitiveValue(entryValue)
+  ]));
+}
+
+// dist/extensions/agent-browser/lib/temp.js
+import { randomBytes } from "node:crypto";
+import { chmod as chmod3, mkdir, mkdtemp as mkdtemp2, open, rm as rm4 } from "node:fs/promises";
+import { dirname as dirname4, join as join5 } from "node:path";
+
+// dist/extensions/agent-browser/lib/temp-mutation-queue.js
+var tempMutationQueue = Promise.resolve();
+function enqueueTempMutation(task) {
+  const nextTask = tempMutationQueue.then(task, task);
+  tempMutationQueue = nextTask.then(() => void 0, () => void 0);
+  return nextTask;
+}
+
+// dist/extensions/agent-browser/lib/temp-root.js
+import { randomInt } from "node:crypto";
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { chmod as chmod2, mkdtemp, readdir as readdir2, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+
+// dist/extensions/agent-browser/lib/temp-root-ownership.js
+import { chmod, readFile as readFile2, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname as dirname2, join as join2, resolve } from "node:path";
+
+// dist/extensions/agent-browser/lib/process-identity.js
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { dirname, join, win32 } from "node:path";
+
+// dist/extensions/agent-browser/lib/browser-execution-policy-debug.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { debuglog } from "node:util";
+var debug = debuglog("pi-agent-browser-policy");
+var policyDebugEnabled = debug.enabled;
+var attempts = policyDebugEnabled ? new AsyncLocalStorage() : void 0;
+var syscalls = /* @__PURE__ */ new Set([
+  "mkdir",
+  "lstat",
+  "stat",
+  "scandir",
+  "open",
+  "read",
+  "write",
+  "rename",
+  "rmdir",
+  "unlink",
+  "rm",
+  "kill",
+  "spawn",
+  "connect",
+  "listen"
+]);
+function debugPolicyFailure(stage, reason, error) {
+  if (!policyDebugEnabled) {
+    return;
+  }
+  const context = attempts?.getStore();
+  const code = nativeField(error, "code");
+  const syscall = nativeField(error, "syscall");
+  const exit = isRecord(error) && typeof error.code === "number" && Number.isSafeInteger(error.code) ? error.code : "-";
+  debug("attempt=%s phase=%s stage=%s reason=%s code=%s syscall=%s exit=%s", context?.attempt ?? 0, context?.phase ?? "standalone", stage, reason, code, syscall, exit);
+}
+function nativeField(error, field) {
+  const value = isRecord(error) ? error[field] : void 0;
+  if (typeof value !== "string") {
+    return "-";
+  }
+  if (field === "code") {
+    return /^(?:E[A-Z0-9]{1,24}|ABORT_ERR|ERR_[A-Z_]{1,48})$/.test(value) ? value : "unknown";
+  }
+  if (value.startsWith("spawn ")) {
+    return "spawn";
+  }
+  return syscalls.has(value) ? value : "unknown";
+}
+
+// dist/extensions/agent-browser/lib/process-identity.js
+var WINDOWS_PROCESS_START_IDENTITY_PREFIX = "win32-powershell-ticks-v1:";
+var POSIX_PROCESS_START_IDENTITY_PREFIX = "posix-ps-utc-v1:";
+var LINUX_PROCESS_START_IDENTITY_PREFIX = "linux-proc-boot-ticks-v1:";
+var PROCESS_START_IDENTITY_FORMATS = [
+  WINDOWS_PROCESS_START_IDENTITY_PREFIX,
+  POSIX_PROCESS_START_IDENTITY_PREFIX,
+  LINUX_PROCESS_START_IDENTITY_PREFIX
+];
+var PROCESS_START_IDENTITY_TIMEOUT_MS = process.platform === "win32" ? 1e4 : 5e3;
+var DEFAULT_WINDOWS_SYSTEM_ROOT = "C:\\Windows";
+var LINUX_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id";
+var LINUX_BOOT_ID_PATTERN = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+var LINUX_STAT_START_TICKS_INDEX = 22 - 3;
+function buildProcessStartIdentityCommand(pid, platform = process.platform) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || platform === "linux") {
+    return void 0;
+  }
+  const configuredSystemRoot = process.env.SystemRoot;
+  const windowsSystemRoot = configuredSystemRoot !== void 0 && configuredSystemRoot.length > 0 && win32.isAbsolute(configuredSystemRoot) ? configuredSystemRoot : DEFAULT_WINDOWS_SYSTEM_ROOT;
+  return platform === "win32" ? {
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `$ErrorActionPreference = 'Stop'; $p = $null; try { $p = [System.Diagnostics.Process]::GetProcessById(${pid}); [long]$ticks = $p.StartTime.ToUniversalTime().Ticks; if ($ticks -le 0) { throw 'Process start ticks unavailable' }; [Console]::Out.WriteLine("${WINDOWS_PROCESS_START_IDENTITY_PREFIX}" + $ticks.ToString([Globalization.CultureInfo]::InvariantCulture)) } finally { if ($null -ne $p) { $p.Dispose() } }`
+    ],
+    file: win32.join(windowsSystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+  } : {
+    args: ["-p", String(pid), "-o", "lstart="],
+    env: { ...process.env, TZ: "UTC0", LC_ALL: "C" },
+    file: platform === "android" ? join(dirname(process.execPath), "ps") : "/bin/ps"
+  };
+}
+function buildProcessStartIdentityCommands(pid, platform = process.platform) {
+  const primary = buildProcessStartIdentityCommand(pid, platform);
+  if (!primary) {
+    return [];
+  }
+  return platform === "win32" ? [primary] : [
+    primary,
+    ...platform === "android" ? [
+      { ...primary, file: "/bin/ps" },
+      { ...primary, file: "/usr/bin/ps" }
+    ] : [
+      { ...primary, file: "/usr/bin/ps" },
+      { ...primary, file: "ps" }
+    ]
+  ];
+}
+function normalizeProcessStartIdentity(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0 || trimmed.includes("\0") || /[\r\n]/.test(trimmed)) {
+    return void 0;
+  }
+  return trimmed.replace(/\s+/g, " ");
+}
+var currentProcessStartIdentityPromise;
+var currentProcessStartIdentity;
+function debugIdentityBudget(budget) {
+  debugPolicyFailure("probe.budget", budget?.signal?.aborted === true ? "cancelled" : "deadline");
+}
+async function executeProcessStartIdentityCommand(command, budget = {}) {
+  if (budget.signal?.aborted === true || budget.deadline !== void 0 && performance.now() >= budget.deadline) {
+    debugIdentityBudget(budget);
+    return void 0;
+  }
+  const timeout = Math.max(1, Math.ceil(Math.min(PROCESS_START_IDENTITY_TIMEOUT_MS, (budget.deadline ?? Infinity) - performance.now())));
+  return await new Promise((resolve3) => {
+    execFile(command.file, command.args, { env: command.env, timeout, signal: budget.signal }, (error, stdout) => {
+      const identity = error ? void 0 : normalizeProcessStartIdentity(stdout);
+      if (identity === void 0) {
+        debugPolicyFailure("probe.execute", error ? "native-error" : "invalid-output", error);
+      }
+      resolve3(identity);
+    });
+  });
+}
+async function resolveProcessStartIdentityFromCommands(commands, execute = executeProcessStartIdentityCommand) {
+  for (const command of commands) {
+    const identity = await execute(command);
+    if (identity !== void 0 && identity.length > 0) {
+      return identity;
+    }
+  }
+  return void 0;
+}
+async function readLinuxProcfsText(path, budget) {
+  if (identityBudgetExpired(budget)) {
+    debugIdentityBudget(budget);
+    return void 0;
+  }
+  try {
+    return await readFile(path, { encoding: "latin1", signal: budget.signal });
+  } catch (error) {
+    debugPolicyFailure("probe.read", "native-error", error);
+    return void 0;
+  }
+}
+async function readLinuxBootId(budget) {
+  const bootId = (await readLinuxProcfsText(LINUX_BOOT_ID_PATH, budget))?.replace(/\n$/, "");
+  if (bootId === void 0 || !LINUX_BOOT_ID_PATTERN.test(bootId)) {
+    debugPolicyFailure("probe.boot-id", bootId === void 0 ? "unavailable" : "invalid-output");
+    return void 0;
+  }
+  return bootId;
+}
+function parseLinuxStartTicks(stat4, pid) {
+  const header = `${String(pid)} (`;
+  const commEnd = stat4.lastIndexOf(")");
+  if (!stat4.startsWith(header) || commEnd < header.length || stat4[commEnd + 1] !== " ") {
+    return void 0;
+  }
+  const ticks = stat4.slice(commEnd + 2).replace(/\n$/, "").split(" ").at(LINUX_STAT_START_TICKS_INDEX);
+  return ticks !== void 0 && /^[0-9]+$/.test(ticks) ? ticks : void 0;
+}
+async function readLinuxProcessStartIdentity(pid, budget = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return void 0;
+  }
+  const bootId = await readLinuxBootId(budget);
+  if (bootId === void 0) {
+    return void 0;
+  }
+  const stat4 = await readLinuxProcfsText(`/proc/${String(pid)}/stat`, budget);
+  if (stat4 === void 0) {
+    return void 0;
+  }
+  const ticks = parseLinuxStartTicks(stat4, pid);
+  if (ticks === void 0) {
+    debugPolicyFailure("probe.stat", "invalid-output");
+    return void 0;
+  }
+  return `${LINUX_PROCESS_START_IDENTITY_PREFIX}${bootId}:${ticks}`;
+}
+async function readUncachedProcessStartIdentity(pid, platform, budget) {
+  if (platform === "linux") {
+    return await readLinuxProcessStartIdentity(pid, budget);
+  }
+  const identity = await resolveProcessStartIdentityFromCommands(buildProcessStartIdentityCommands(pid, platform), (command) => executeProcessStartIdentityCommand(command, budget));
+  return identity === void 0 || platform === "win32" ? identity : `${POSIX_PROCESS_START_IDENTITY_PREFIX}${identity}`;
+}
+function identityBudgetExpired(budget) {
+  return budget?.signal?.aborted === true || budget?.deadline !== void 0 && performance.now() >= budget.deadline;
+}
+async function readProcessStartIdentity(pid, platform = process.platform, budget) {
+  if (identityBudgetExpired(budget)) {
+    debugIdentityBudget(budget);
+    return void 0;
+  }
+  if (pid !== process.pid || platform !== process.platform) {
+    return await readUncachedProcessStartIdentity(pid, platform, budget);
+  }
+  if (currentProcessStartIdentity !== void 0 && currentProcessStartIdentity.length > 0) {
+    return currentProcessStartIdentity;
+  }
+  if (budget) {
+    const identity = await readUncachedProcessStartIdentity(pid, platform, budget);
+    if (identity !== void 0 && identity.length > 0) {
+      currentProcessStartIdentity = identity;
+    }
+    return identity;
+  }
+  return await readCachedProcessStartIdentity(pid, platform);
+}
+async function readCachedProcessStartIdentity(pid, platform) {
+  currentProcessStartIdentityPromise ??= readUncachedProcessStartIdentity(pid, platform).then((identity) => {
+    if (identity === void 0 || identity.length === 0) {
+      currentProcessStartIdentityPromise = void 0;
+    } else {
+      currentProcessStartIdentity = identity;
+    }
+    return identity;
+  });
+  return await currentProcessStartIdentityPromise;
+}
+function processStartIdentitiesMatch(recorded, current) {
+  const format = PROCESS_START_IDENTITY_FORMATS.find((prefix) => current.startsWith(prefix));
+  if (format === void 0 || !recorded.startsWith(format)) {
+    return void 0;
+  }
+  return recorded === current;
+}
+
+// dist/extensions/agent-browser/lib/process-errors.js
+function getErrorCode(error) {
+  return isRecord(error) && typeof error.code === "string" ? error.code : void 0;
+}
+
+// dist/extensions/agent-browser/lib/temp-root-ownership.js
+var TEMP_ROOT_MARKER_FILE_NAME = ".pi-agent-browser-owner.json";
+var TEMP_ROOT_MARKER_KIND = "pi-agent-browser-temp-root";
+var TEMP_ROOT_MARKER_VERSION = 2;
+function getCurrentProcessUid() {
+  return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+function isPositiveFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isProtectedTempChildName(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  if (value === "" || value === "." || value === ".." || value === TEMP_ROOT_MARKER_FILE_NAME) {
+    return false;
+  }
+  if (value.includes("/") || value.includes("\\")) {
+    return false;
+  }
+  return basename(value) === value;
+}
+function isTempRootOwnershipRecord(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.kind !== TEMP_ROOT_MARKER_KIND || value.version !== TEMP_ROOT_MARKER_VERSION) {
+    return false;
+  }
+  if (!isPositiveFiniteNumber(value.createdAtMs)) {
+    return false;
+  }
+  return validLeaseAndProcess(value) && validOwnershipAndChildren(value);
+}
+function validLeaseAndProcess(value) {
+  if (value.leaseUpdatedAtMs !== void 0 && !isPositiveFiniteNumber(value.leaseUpdatedAtMs)) {
+    return false;
+  }
+  if (value.ownerPid !== void 0 && (typeof value.ownerPid !== "number" || !Number.isSafeInteger(value.ownerPid) || value.ownerPid <= 0)) {
+    return false;
+  }
+  return value.ownerProcessStartIdentity === void 0 || typeof value.ownerProcessStartIdentity === "string" && value.ownerProcessStartIdentity.trim() !== "";
+}
+function validOwnershipAndChildren(value) {
+  if (value.ownerUid !== void 0 && (typeof value.ownerUid !== "number" || !Number.isSafeInteger(value.ownerUid) || value.ownerUid < 0)) {
+    return false;
+  }
+  if (value.protectedChildNames === void 0) {
+    return true;
+  }
+  if (!Array.isArray(value.protectedChildNames)) {
+    return false;
+  }
+  const names = value.protectedChildNames;
+  return names.every(isProtectedTempChildName);
+}
+async function readTempRootOwnershipMarker(tempRoot) {
+  try {
+    const markerText = await readFile2(join2(tempRoot, TEMP_ROOT_MARKER_FILE_NAME), "utf8");
+    const parsed = JSON.parse(markerText);
+    return isTempRootOwnershipRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getPersistedProtectedChildPaths(tempRoot, ownershipMarker) {
+  const normalizedTempRoot = resolve(tempRoot);
+  return new Set((ownershipMarker?.protectedChildNames ?? []).map((childName) => resolve(join2(normalizedTempRoot, childName))));
+}
+async function writeTempRootOwnershipMarkerRecord(tempRoot, markerRecord, options = {}) {
+  const markerPath = join2(tempRoot, TEMP_ROOT_MARKER_FILE_NAME);
+  await writeFile(markerPath, JSON.stringify(markerRecord, null, 2), {
+    encoding: "utf8",
+    flag: options.flag,
+    mode: 384
+  });
+  await chmod(markerPath, 384).catch(() => void 0);
+  return markerPath;
+}
+async function getExistingProtectedChildren(tempRoot, protectedChildren) {
+  const normalizedTempRoot = resolve(tempRoot);
+  const existingChildren = /* @__PURE__ */ new Set();
+  for (const path of protectedChildren) {
+    const normalizedPath = resolve(path);
+    if (dirname2(normalizedPath) !== normalizedTempRoot) {
+      continue;
+    }
+    if (
+      // Scan in bounded sequence instead of opening an unbounded number of filesystem requests.
+      // oxlint-disable-next-line no-await-in-loop
+      await stat(normalizedPath).then((stats) => stats.isDirectory(), () => false)
+    ) {
+      existingChildren.add(normalizedPath);
+    }
+  }
+  return existingChildren;
+}
+async function removeTempRootChildrenExcept(tempRoot, protectedChildren) {
+  const entries = await readdir(tempRoot, { withFileTypes: true }).catch(() => []);
+  await Promise.all(entries.map(async (entry) => {
+    if (entry.name === TEMP_ROOT_MARKER_FILE_NAME) {
+      return;
+    }
+    const entryPath = join2(tempRoot, entry.name);
+    if (protectedChildren.has(resolve(entryPath))) {
+      return;
+    }
+    await rm(entryPath, { force: true, recursive: true }).catch(() => void 0);
+  }));
+}
+async function getProcessStartIdentity(pid) {
+  return pid === void 0 ? void 0 : await readProcessStartIdentity(pid);
+}
+async function writeSecureTempRootOwnershipMarker(tempRoot, options = {}) {
+  const createdAtMs = options.createdAtMs ?? Date.now();
+  const ownerPid = options.ownerPid ?? process.pid;
+  const markerRecord = {
+    createdAtMs,
+    kind: TEMP_ROOT_MARKER_KIND,
+    leaseUpdatedAtMs: options.leaseUpdatedAtMs ?? createdAtMs,
+    ownerPid,
+    ownerProcessStartIdentity: options.ownerProcessStartIdentity ?? await getProcessStartIdentity(ownerPid),
+    ownerUid: getCurrentProcessUid(),
+    version: TEMP_ROOT_MARKER_VERSION
+  };
+  return await writeTempRootOwnershipMarkerRecord(tempRoot, markerRecord, { flag: "wx" });
+}
+async function refreshSecureTempRootLease(tempRoot) {
+  const ownershipMarker = await readTempRootOwnershipMarker(tempRoot);
+  if (!ownershipMarker) {
+    return;
+  }
+  if (ownershipMarker.ownerPid !== process.pid) {
+    return;
+  }
+  const currentUid = getCurrentProcessUid();
+  if (currentUid !== void 0 && ownershipMarker.ownerUid !== void 0 && ownershipMarker.ownerUid !== currentUid) {
+    return;
+  }
+  const currentProcessStartIdentity2 = await getProcessStartIdentity(process.pid);
+  if (ownershipMarker.ownerProcessStartIdentity !== void 0 && currentProcessStartIdentity2 !== void 0) {
+    const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity2);
+    if (identitiesMatch !== true) {
+      return;
+    }
+  }
+  const refreshedMarker = {
+    ...ownershipMarker,
+    leaseUpdatedAtMs: Date.now(),
+    ownerPid: process.pid,
+    ownerProcessStartIdentity: currentProcessStartIdentity2 ?? ownershipMarker.ownerProcessStartIdentity,
+    ownerUid: currentUid,
+    version: TEMP_ROOT_MARKER_VERSION
+  };
+  await writeTempRootOwnershipMarkerRecord(tempRoot, refreshedMarker);
+}
+async function getMarkerOwnerLiveness(ownershipMarker) {
+  const pid = ownershipMarker.ownerPid;
+  if (pid === void 0) {
+    return "unknown";
+  }
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    const code = getErrorCode(error);
+    if (code === "ESRCH") {
+      return "dead";
+    }
+    if (code !== "EPERM") {
+      return "unknown";
+    }
+  }
+  const currentProcessStartIdentity2 = await getProcessStartIdentity(pid);
+  if (ownershipMarker.ownerProcessStartIdentity === void 0 || currentProcessStartIdentity2 === void 0) {
+    return "unknown";
+  }
+  const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity2);
+  if (identitiesMatch === void 0) {
+    return "unknown";
+  }
+  return identitiesMatch ? "alive" : "dead";
+}
+
+// dist/extensions/agent-browser/lib/temp-root.js
+var TEMP_ROOT_PREFIX = "pi-agent-browser-";
+var STALE_TEMP_ROOT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var STALE_TEMP_ROOT_BATCH_SIZE = 8;
+var lastTempGcName;
+var sessionTempRootPromise;
+var exitCleanupRegistered = false;
+var ownedTempRoots = /* @__PURE__ */ new Set();
+var protectedTempChildren = /* @__PURE__ */ new Set();
+function markerMatchesUid(marker, uid) {
+  return uid === void 0 || marker.ownerUid === void 0 || marker.ownerUid === uid;
+}
+async function pruneTempRoot(path, currentUid, cutoffTime) {
+  const marker = await readTempRootOwnershipMarker(path);
+  if (!marker || !markerMatchesUid(marker, currentUid)) {
+    return;
+  }
+  if ((marker.leaseUpdatedAtMs ?? marker.createdAtMs) >= cutoffTime) {
+    return;
+  }
+  if (await getMarkerOwnerLiveness(marker) !== "dead") {
+    return;
+  }
+  const stats = await stat2(path).catch(() => void 0);
+  if (stats?.isDirectory() !== true) {
+    return;
+  }
+  const protectedChildren = await getExistingProtectedChildren(path, getPersistedProtectedChildPaths(path, marker));
+  if (protectedChildren.size > 0) {
+    await removeTempRootChildrenExcept(path, protectedChildren);
+    return;
+  }
+  await rm2(path, { force: true, recursive: true }).catch(() => {
+  });
+}
+async function pruneStaleTempRoots(currentTempRoot) {
+  const entries = await readdir2(tmpdir(), { withFileTypes: true }).catch(() => []);
+  const cutoffTime = Date.now() - STALE_TEMP_ROOT_MAX_AGE_MS;
+  const currentUid = getCurrentProcessUid();
+  const candidates = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(TEMP_ROOT_PREFIX)).map((entry) => entry.name).sort();
+  if (candidates.length === 0) {
+    return;
+  }
+  const previousName = lastTempGcName;
+  const start = previousName === void 0 ? randomInt(candidates.length) : Math.max(0, candidates.findIndex((name) => name > previousName));
+  const batch = Array.from({ length: Math.min(STALE_TEMP_ROOT_BATCH_SIZE, candidates.length) }, (_, offset) => candidates[(start + offset) % candidates.length]);
+  lastTempGcName = batch.at(-1);
+  await Promise.all(batch.map(async (name) => {
+    const path = join3(tmpdir(), name);
+    if (path !== currentTempRoot) {
+      await pruneTempRoot(path, currentUid, cutoffTime);
+    }
+  }));
+}
+function getProtectedChildrenForRoot(tempRoot) {
+  const normalizedTempRoot = resolve2(tempRoot);
+  return new Set([...protectedTempChildren].filter((path) => dirname3(path) === normalizedTempRoot && existsSync(path)));
+}
+function removeTempRootChildrenExceptSync(tempRoot, protectedChildren) {
+  for (const entry of readdirSync(tempRoot, { withFileTypes: true })) {
+    if (entry.name === TEMP_ROOT_MARKER_FILE_NAME) {
+      continue;
+    }
+    const entryPath = join3(tempRoot, entry.name);
+    if (protectedChildren.has(resolve2(entryPath))) {
+      continue;
+    }
+    rmSync(entryPath, { force: true, recursive: true });
+  }
+}
+function registerExitCleanup() {
+  if (exitCleanupRegistered) {
+    return;
+  }
+  exitCleanupRegistered = true;
+  process.once("exit", () => {
+    for (const tempRoot of ownedTempRoots) {
+      try {
+        const protectedChildren = getProtectedChildrenForRoot(tempRoot);
+        if (protectedChildren.size === 0) {
+          rmSync(tempRoot, { force: true, recursive: true });
+        } else {
+          removeTempRootChildrenExceptSync(tempRoot, protectedChildren);
+        }
+      } catch {
+      }
+    }
+  });
+}
+async function allocateSessionTempRoot() {
+  const tempRoot = await mkdtemp(join3(tmpdir(), TEMP_ROOT_PREFIX));
+  try {
+    await chmod2(tempRoot, 448).catch(() => {
+    });
+    await writeSecureTempRootOwnershipMarker(tempRoot);
+    ownedTempRoots.add(tempRoot);
+    registerExitCleanup();
+    return tempRoot;
+  } catch (error) {
+    await rm2(tempRoot, { force: true, recursive: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+async function getSessionTempRoot() {
+  sessionTempRootPromise ??= allocateSessionTempRoot().catch((error) => {
+    sessionTempRootPromise = void 0;
+    throw error;
+  });
+  const tempRoot = await sessionTempRootPromise;
+  await refreshSecureTempRootLease(tempRoot).catch(() => {
+  });
+  await pruneStaleTempRoots(tempRoot).catch(() => {
+  });
+  return tempRoot;
+}
+
+// dist/extensions/agent-browser/lib/temp-artifact-budget.js
+import { readdir as readdir3, rm as rm3, stat as stat3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+function getTempArtifactByteLength(content) {
+  return typeof content === "string" ? Buffer.byteLength(content) : content.byteLength;
+}
+async function listArtifactFiles(directory, excludedNames = /* @__PURE__ */ new Set()) {
+  const entries = await readdir3(directory, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  const candidates = entries.filter((entry) => entry.isFile() && !excludedNames.has(entry.name));
+  for (let index = 0; index < candidates.length; index += 4) {
+    const batch = await Promise.all(candidates.slice(index, index + 4).map(async (entry) => {
+      const path = join4(directory, entry.name);
+      const stats = await stat3(path).catch(() => void 0);
+      return stats?.isFile() === true ? { mtimeMs: stats.mtimeMs, path, size: stats.size } : void 0;
+    }));
+    for (const file of batch) {
+      if (file !== void 0) {
+        files.push(file);
+      }
+    }
+  }
+  return files;
+}
+function getSecureTempRootMaxBytes(env = process.env) {
+  return parsePositiveInteger(env.PI_AGENT_BROWSER_TEMP_ROOT_MAX_BYTES) ?? DEFAULT_MAX_BYTES;
+}
+function getPersistentSessionArtifactMaxBytes(env = process.env) {
+  if (env.PI_AGENT_BROWSER_SESSION_ARTIFACT_MAX_BYTES?.trim() === "0") {
+    return 0;
+  }
+  return parsePositiveInteger(env.PI_AGENT_BROWSER_SESSION_ARTIFACT_MAX_BYTES) ?? DEFAULT_MAX_BYTES;
+}
+async function assertSecureTempRootBudget(tempRoot, additionalBytes) {
+  if (additionalBytes <= 0) {
+    return;
+  }
+  const files = await listArtifactFiles(tempRoot, /* @__PURE__ */ new Set([".pi-agent-browser-owner.json"]));
+  const currentBytes = files.reduce((total, file) => total + file.size, 0);
+  const maxBytes = getSecureTempRootMaxBytes();
+  const nextBytes = currentBytes + additionalBytes;
+  if (nextBytes > maxBytes) {
+    throw new Error(`pi-agent-browser temp spill budget exceeded (${nextBytes} bytes > ${maxBytes} byte limit).`);
+  }
+}
+async function prunePersistentSessionArtifactsToBudget(sessionArtifactDir, additionalBytes, protectedPaths) {
+  if (additionalBytes <= 0) {
+    return [];
+  }
+  const maxBytes = getPersistentSessionArtifactMaxBytes();
+  if (maxBytes === 0) {
+    return [];
+  }
+  const files = await listArtifactFiles(sessionArtifactDir);
+  let totalBytes = files.reduce((total, file) => total + file.size, 0);
+  if (totalBytes + additionalBytes <= maxBytes) {
+    return [];
+  }
+  const evictedArtifacts = [];
+  files.sort((left, right) => {
+    const time = left.mtimeMs - right.mtimeMs;
+    return time === 0 ? left.path.localeCompare(right.path) : time;
+  });
+  for (const file of files) {
+    if (protectedPaths.has(file.path)) {
+      continue;
+    }
+    const removed = await rm3(file.path, { force: true }).then(() => true, () => false);
+    if (!removed) {
+      continue;
+    }
+    evictedArtifacts.push({ mtimeMs: file.mtimeMs, path: file.path, sizeBytes: file.size });
+    totalBytes -= file.size;
+    if (totalBytes + additionalBytes <= maxBytes) {
+      return evictedArtifacts;
+    }
+  }
+  throw new Error(`pi-agent-browser persisted spill budget exceeded (${totalBytes + additionalBytes} bytes > ${maxBytes} byte limit).`);
+}
+
+// dist/extensions/agent-browser/lib/temp.js
+async function ensurePersistentSessionArtifactDir(store) {
+  const rootDir = join5(store.sessionDir, ".pi-agent-browser-artifacts");
+  const sessionDir = join5(rootDir, store.sessionId);
+  await mkdir(rootDir, { recursive: true, mode: 448 });
+  await chmod3(rootDir, 448).catch(() => {
+  });
+  await mkdir(sessionDir, { recursive: true, mode: 448 });
+  await chmod3(sessionDir, 448).catch(() => {
+  });
+  return sessionDir;
+}
+async function openSecureTempFile(prefix, suffix) {
+  const tempRoot = await getSessionTempRoot();
+  const path = join5(tempRoot, `${prefix}-${randomBytes(8).toString("hex")}${suffix}`);
+  const fileHandle = await open(path, "wx", 384);
+  return { fileHandle, path };
+}
+async function writeSecureTempChunk(options) {
+  const { content, fileHandle, path } = options;
+  await enqueueTempMutation(async () => {
+    const tempRoot = dirname4(path);
+    await refreshSecureTempRootLease(tempRoot).catch(() => {
+    });
+    await assertSecureTempRootBudget(tempRoot, getTempArtifactByteLength(content));
+    await fileHandle.appendFile(content);
+  });
+}
+async function writeSecureTempFile(options) {
+  const { content, prefix, suffix } = options;
+  const { fileHandle, path } = await openSecureTempFile(prefix, suffix);
+  try {
+    await writeSecureTempChunk({ content, fileHandle, path });
+  } catch (error) {
+    await rm4(path, { force: true }).catch(() => {
+    });
+    throw error;
+  } finally {
+    await fileHandle.close();
+  }
+  return path;
+}
+async function writePersistentSessionArtifactFile(options) {
+  const { content, prefix, store, suffix } = options;
+  return await enqueueTempMutation(async () => {
+    const artifactDir = await ensurePersistentSessionArtifactDir(store);
+    const evictedArtifacts = await prunePersistentSessionArtifactsToBudget(artifactDir, getTempArtifactByteLength(content), new Set((store.protectedPaths ?? []).filter((path2) => dirname4(path2) === artifactDir)));
+    const path = join5(artifactDir, `${prefix}-${randomBytes(8).toString("hex")}${suffix}`);
+    const fileHandle = await open(path, "wx", 384);
+    try {
+      await fileHandle.writeFile(content);
+    } catch (error) {
+      await rm4(path, { force: true }).catch(() => {
+      });
+      throw error;
+    } finally {
+      await fileHandle.close().catch(() => {
+      });
+    }
+    return { evictedArtifacts, path };
+  });
+}
+
+// dist/extensions/agent-browser/lib/results/artifact-manifest.js
+function isPendingRecordingCommand(command, subcommand, kind) {
+  return command === "record" && (subcommand === "start" || subcommand === "restart") && kind === "video";
+}
+function isPendingRecordingArtifact(artifact) {
+  return artifact.recordingState === "openRecording" || artifact.status === "pending" || artifact.status === void 0 && isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind);
+}
+var SESSION_ARTIFACT_MANIFEST_VERSION = 1;
+var SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES_ENV = "PI_AGENT_BROWSER_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES";
+var DEFAULT_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES = 100;
+function parsePositiveSafeInteger(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    return void 0;
+  }
+  return parsed;
+}
+function getSessionArtifactManifestMaxEntries(env = process.env) {
+  return parsePositiveSafeInteger(env[SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES_ENV]) ?? DEFAULT_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES;
+}
+function buildEvictedSessionArtifactEntries(evictedArtifacts, nowMs) {
+  return evictedArtifacts.map((artifact) => ({
+    createdAtMs: artifact.mtimeMs,
+    evictedAtMs: nowMs,
+    kind: "spill",
+    path: artifact.path,
+    retentionState: "evicted",
+    sizeBytes: artifact.sizeBytes,
+    storageScope: "persistent-session"
+  }));
+}
+function formatSessionArtifactRetentionSummary(manifest) {
+  const ephemeralCount = manifest.entries.filter((entry) => entry.retentionState === "ephemeral").length;
+  const missingCount = manifest.entries.filter((entry) => entry.retentionState === "missing").length;
+  const parts = [`${manifest.liveCount} live`, `${manifest.evictedCount} evicted`];
+  if (ephemeralCount > 0) {
+    parts.push(`${ephemeralCount} ephemeral`);
+  }
+  if (missingCount > 0) {
+    parts.push(`${missingCount} missing`);
+  }
+  return `Session artifacts: ${parts.join(", ")} (${manifest.entries.length}/${manifest.maxEntries} recent).`;
+}
+function getSessionArtifactManifestEntryKey(entry) {
+  const pathKey = entry.storageScope === "explicit-path" && entry.absolutePath !== void 0 && entry.absolutePath.length > 0 ? `${entry.storageScope}:${entry.absolutePath}` : `${entry.storageScope}:${entry.path}`;
+  const recordingSessionKey = entry.command === "record" && entry.kind === "video" && entry.session !== void 0 && entry.session.length > 0 ? getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) : void 0;
+  return recordingSessionKey !== void 0 && recordingSessionKey.length > 0 ? `${pathKey}\0${recordingSessionKey}` : pathKey;
+}
+function getSupersededRecordingKeys(candidates, entry, key) {
+  if (entry.command !== "record" || entry.kind !== "video") {
+    return [];
+  }
+  const entrySessionKey = entry.session !== void 0 && entry.session.length > 0 ? getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) : void 0;
+  return [...candidates].filter(([candidateKey, candidate]) => {
+    const sameRecordingSession = entrySessionKey === void 0 ? candidate.session === void 0 : candidate.session !== void 0 && getAgentBrowserSessionIdentityKey(candidate.session, candidate.namespace) === entrySessionKey;
+    return candidateKey !== key && sameRecordingSession && candidate.kind === "video" && isPendingRecordingArtifact(candidate);
+  }).map(([candidateKey]) => candidateKey);
+}
+function mergeManifestEntry(existing, entry, nowMs) {
+  return {
+    ...existing,
+    ...entry,
+    createdAtMs: entry.command === "record" && entry.kind === "video" ? entry.createdAtMs : existing?.createdAtMs ?? entry.createdAtMs,
+    evictedAtMs: entry.retentionState === "evicted" ? entry.evictedAtMs ?? nowMs : entry.evictedAtMs
+  };
+}
+function compareManifestEntries(left, right) {
+  const difference = (right.evictedAtMs ?? right.createdAtMs) - (left.evictedAtMs ?? left.createdAtMs);
+  if (difference !== 0 && !Number.isNaN(difference)) {
+    return difference;
+  }
+  const pendingDifference = Number(isPendingRecordingArtifact(right)) - Number(isPendingRecordingArtifact(left));
+  return pendingDifference !== 0 ? pendingDifference : left.path.localeCompare(right.path);
+}
+function mergeSessionArtifactManifest(options) {
+  const nowMs = options.nowMs ?? Date.now();
+  const maxEntries = getSessionArtifactManifestMaxEntries();
+  const byPath = /* @__PURE__ */ new Map();
+  for (const entry of options.base?.entries ?? []) {
+    byPath.set(getSessionArtifactManifestEntryKey(entry), entry);
+  }
+  const orderedEntries = (options.entries ?? []).map((entry, index) => ({ entry, index })).sort((left, right) => {
+    const difference = left.entry.createdAtMs - right.entry.createdAtMs;
+    return difference !== 0 && !Number.isNaN(difference) ? difference : left.index - right.index;
+  }).map(({ entry }) => entry);
+  for (const entry of orderedEntries) {
+    const key = getSessionArtifactManifestEntryKey(entry);
+    for (const candidateKey of getSupersededRecordingKeys(byPath, entry, key)) {
+      byPath.delete(candidateKey);
+    }
+    const existing = byPath.get(key);
+    byPath.set(key, mergeManifestEntry(existing, entry, nowMs));
+  }
+  if (byPath.size === 0) {
+    return void 0;
+  }
+  const entries = [...byPath.values()].sort(compareManifestEntries).slice(0, maxEntries);
+  return {
+    entries,
+    evictedCount: entries.filter((entry) => entry.retentionState === "evicted").length,
+    liveCount: entries.filter((entry) => entry.retentionState === "live").length,
+    maxEntries,
+    updatedAtMs: nowMs,
+    version: SESSION_ARTIFACT_MANIFEST_VERSION
+  };
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot-spill.js
+var SNAPSHOT_SPILL_FILE_PREFIX = "pi-agent-browser-snapshot";
+async function writeSnapshotSpillFile(data, persistentArtifactStore) {
+  const options = {
+    content: JSON.stringify(redactSensitiveValue(data), null, 2),
+    prefix: SNAPSHOT_SPILL_FILE_PREFIX,
+    suffix: ".json"
+  };
+  if (persistentArtifactStore) {
+    const result = await writePersistentSessionArtifactFile({
+      ...options,
+      store: persistentArtifactStore
+    });
+    return { ...result, storageScope: "persistent-session" };
+  }
+  return {
+    evictedArtifacts: [],
+    path: await writeSecureTempFile(options),
+    storageScope: "process-temp"
+  };
+}
+function applySnapshotArtifactManifest(options) {
+  if (options.fullOutputPath === void 0 || options.fullOutputPath.length === 0 || !options.spill) {
+    return {};
+  }
+  const nowMs = Date.now();
+  const entries = [
+    {
+      command: options.command,
+      createdAtMs: nowMs,
+      kind: "spill",
+      path: options.fullOutputPath,
+      retentionState: options.spill.storageScope === "persistent-session" ? "live" : "ephemeral",
+      storageScope: options.spill.storageScope
+    },
+    ...buildEvictedSessionArtifactEntries(options.spill.evictedArtifacts, nowMs)
+  ];
+  const artifactManifest = mergeSessionArtifactManifest({
+    base: options.baseManifest,
+    entries,
+    nowMs
+  });
+  return artifactManifest ? {
+    artifactManifest,
+    artifactRetentionSummary: formatSessionArtifactRetentionSummary(artifactManifest)
+  } : {};
+}
+
+// dist/extensions/agent-browser/lib/results/snapshot.js
+function shouldCompactSnapshot(rawText, data) {
+  return rawText.length > 6e3 || countLines(getSnapshotText(data) ?? "") > 80 || Object.keys(getSnapshotRefRecord(data) ?? {}).length > 60;
+}
+async function getSnapshotSpill(data, store) {
+  try {
+    const spill = await writeSnapshotSpillFile(data, store);
+    return { spill, fullOutputPath: spill.path };
+  } catch (error) {
+    return { spillErrorText: error instanceof Error ? error.message : stringifyUnknown(error) };
+  }
+}
+async function buildSnapshotPresentation(data, persistentArtifactStore, artifactManifest) {
+  const summary = formatSnapshotSummary(data);
+  const rawText = formatRawSnapshotText(data);
+  if (isRecord(data.snapshot) && data.snapshot.kind !== "full" || !shouldCompactSnapshot(rawText, data)) {
+    return { content: [{ type: "text", text: rawText }], data, summary };
+  }
+  const { spill, fullOutputPath, spillErrorText } = await getSnapshotSpill(data, persistentArtifactStore);
+  const compact = buildCompactSnapshotView(data, fullOutputPath, spillErrorText);
+  const manifestFields = applySnapshotArtifactManifest({
+    baseManifest: artifactManifest,
+    command: "snapshot",
+    fullOutputPath,
+    spill
+  });
+  const notice = manifestFields.artifactRetentionSummary;
+  const text = compact.content.at(0);
+  if (notice !== void 0 && notice.length > 0 && text?.type === "text") {
+    compact.content[0] = { type: "text", text: `${text.text}
+
+${notice}` };
+  }
+  return { ...manifestFields, ...compact, fullOutputPath, summary: `${summary} (compact)` };
+}
+export {
+  buildSnapshotPresentation,
+  formatRawSnapshotText,
+  formatSnapshotSummary
+};