@runcofactor/cli 0.10.0 → 0.13.0

package/dist/{chunk-4PNOV7OV.js → chunk-QQVWGWPI.js}

@@ -2,6 +2,9 @@ import { createRequire as __cr } from "module"; const require = __cr(import.meta
 import {
   getCanaryTmpDir
 } from "./chunk-JWHYXEA2.js";
+import {
+  isVolatileIdentifier
+} from "./chunk-QGI4UCJX.js";
 import {
   require_src
 } from "./chunk-6LEZCKKV.js";
@@ -25583,8 +25586,22 @@ var TIMEOUTS = {
   POST_ACTION_SNAPSHOT: 15e3,
   // Hard cap for the best-effort `window.stop()` dispatched on per-tool-timeout
   // abort. Bounds wedged JS contexts; a healthy page returns in <10ms.
-  UNWEDGE_PAGE_CAP: 1e3
+  UNWEDGE_PAGE_CAP: 1e3,
+  // Driver-side grace added on top of `__waitDomQuiet`'s in-page maxWaitMs
+  // before the evaluate itself is abandoned. The in-page cap is a page-side
+  // setTimeout that never fires on a blocked main thread; the driver-side
+  // race (maxWaitMs + this grace) guarantees forward progress regardless.
+  WAIT_DOM_QUIET_EVAL_GRACE: 500,
+  // Driver-side cap for the liveness probe (`page.evaluate(() => 1)`). Short on
+  // purpose: a healthy page answers in <10ms; a blocked main thread caps and is
+  // treated as Unresponsive so the per-tool-timeout recovery can tear it down.
+  LIVENESS_PROBE_CAP: 750,
+  // A captured request still 'pending' (no response headers) past this age is
+  // ignored by the HTTP-settle stabilization signal — a long-poll / hung XHR /
+  // header-less streaming fetch must never block a snapshot indefinitely.
+  HTTP_SETTLE_MAX_AGE: 1e4
 };
+var LARGE_PAGE_REF_THRESHOLD = 1500;
 var DEFAULTS = {
   MAX_DEPTH: 10,
   MAX_PAGES: 100,
@@ -25911,6 +25928,10 @@ function extractAndStripV2Fields(attributes) {
         cssHints.testIds.push(value);
         sawCssHint = true;
         break;
+      case "~data-id":
+        cssHints.dataId = value;
+        sawCssHint = true;
+        break;
       case "~automation-id":
         cssHints.automationId = value;
         sawCssHint = true;
@@ -25921,6 +25942,12 @@ function extractAndStripV2Fields(attributes) {
       case "~semantic-class":
         out.semanticClass = value;
         break;
+      case "~field":
+        out.dataField = value;
+        break;
+      case "~editable":
+        out.isEditable = value === "true";
+        break;
       case "~v2":
         out.substrateVersion = 2;
         break;
@@ -26338,6 +26365,7 @@ var RESULT_ITEM_SELECTOR = "[role=option],[role=listitem],[role=row],[data-slot=
 var FILTER_QUERY_MIN_LEN = 3;
 var FILTER_MAX_RESULT_ITEMS = 200;
 var FILTER_ANCESTOR_WALK_DEPTH = 4;
+var HCLIP_ANCESTOR_WALK_DEPTH = 10;
 var MODAL_V2_MAX_ENRICHMENTS = 3;
 var MODAL_V2_FRAMEWORK_SELECTORS = [
   ".cdk-overlay-pane",
@@ -26369,6 +26397,7 @@ var SUB_FRAME_REF_RE = /^f\d+e\d+$/;
 function planChecks(elements, opts) {
   const planByRef = /* @__PURE__ */ new Map();
   const skipGridRefs = opts.skipGridRefs;
+  const hclipCandidates = [];
   const ensure = (ref) => {
     let args = planByRef.get(ref);
     if (!args) {
@@ -26431,9 +26460,32 @@ function planChecks(elements, opts) {
       if (el.role === "switch" || el.role === "checkbox") {
         addCheck(el.ref, "toggle");
       }
-      if (opts.v2 && (INTERACTIVE_ROLES3.has(el.role) || el.role === "option" || el.role === "row" || el.role === "listitem" || el.attributes["cursor"] === "pointer")) {
+      const isTargetableForId = INTERACTIVE_ROLES3.has(el.role) || el.role === "option" || el.role === "row" || el.role === "gridcell" || el.role === "listitem" || el.attributes["cursor"] === "pointer";
+      if (opts.v2 && isTargetableForId) {
         addCheck(el.ref, "testId");
       }
+      if (isTargetableForId) {
+        hclipCandidates.push(el.ref);
+      }
+      const CONTAINER_ROLES_FOR_ID = /* @__PURE__ */ new Set([
+        "generic",
+        "group",
+        "region",
+        "article",
+        "section",
+        "listitem",
+        "rowgroup",
+        "list",
+        "navigation",
+        "complementary",
+        "form"
+      ]);
+      if (opts.v2 && (isTargetableForId || CONTAINER_ROLES_FOR_ID.has(el.role) && hasInteractive(el))) {
+        addCheck(el.ref, "dataId");
+      }
+      if (opts.v2 && (el.role === "gridcell" || el.role === "cell")) {
+        addCheck(el.ref, "dataField");
+      }
       if (el.role === "generic" && el.ref && el.text) {
         addCheck(el.ref, "svgPromote");
       }
@@ -26441,6 +26493,9 @@ function planChecks(elements, opts) {
     for (const child of el.children) walk(child, inGridCell || isGridCell);
   };
   for (const el of elements) walk(el, false);
+  if (hclipCandidates.length <= LARGE_PAGE_REF_THRESHOLD) {
+    for (const ref of hclipCandidates) addCheck(ref, "hclip");
+  }
   return [...planByRef].map(([ref, args]) => ({ ref, args }));
 }
 function pageSideFn(el, _ref, args, G) {
@@ -26462,6 +26517,31 @@ function pageSideFn(el, _ref, args, G) {
     if (disabled) readonly = false;
     out.editability = { readonly, disabled };
   }
+  if (checks.has("hclip")) {
+    out.hclip = null;
+    try {
+      const win = el.ownerDocument.defaultView;
+      if (win) {
+        const elRect = el.getBoundingClientRect();
+        if (elRect.width > 0 || elRect.height > 0) {
+          let parent = el.parentElement;
+          for (let i2 = 0; i2 < G.HCLIP_ANCESTOR_DEPTH && parent; i2++, parent = parent.parentElement) {
+            if (parent.scrollWidth <= parent.clientWidth + 1) continue;
+            const ox = win.getComputedStyle(parent).overflowX;
+            if (ox !== "auto" && ox !== "scroll") continue;
+            const cRect = parent.getBoundingClientRect();
+            const bandLeft = Math.max(cRect.left, 0);
+            const bandRight = Math.min(cRect.right, win.innerWidth);
+            if (elRect.right <= bandLeft) out.hclip = "left";
+            else if (elRect.left >= bandRight) out.hclip = "right";
+            break;
+          }
+        }
+      }
+    } catch {
+      out.hclip = null;
+    }
+  }
   if (checks.has("gridCellValue")) {
     let value = null;
     const title = el.getAttribute("title");
@@ -26795,6 +26875,28 @@ function pageSideFn(el, _ref, args, G) {
       out.testId = null;
     }
   }
+  if (checks.has("dataId")) {
+    try {
+      const dataId = el.getAttribute("data-id") || void 0;
+      out.dataId = dataId && dataId.length <= 120 ? dataId : null;
+    } catch {
+      out.dataId = null;
+    }
+  }
+  if (checks.has("dataField")) {
+    out.dataField = null;
+    try {
+      const field = el.getAttribute("data-field");
+      const reserved = field === "__check__" || field === "__row_number__" || field === "__reorder__" || field === "__detail_panel_toggle__" || field === "__tree_data_group__";
+      if (field && !reserved) {
+        const cls = typeof el.className === "string" ? el.className : "";
+        const editable = /(?:^|[\s-])editable(?:[\s-]|$)/i.test(cls) || el.getAttribute("aria-readonly") === "false" || el.querySelector('input, textarea, select, [contenteditable="true"]') !== null;
+        out.dataField = { field: field.slice(0, 120), editable };
+      }
+    } catch {
+      out.dataField = null;
+    }
+  }
   if (checks.has("svgPromote")) {
     try {
       out.svgPromote = el.hasAttribute("data-svg-enriched");
@@ -26943,6 +27045,7 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
       FILTER_MAX_ITEMS: FILTER_MAX_RESULT_ITEMS,
       FILTER_MIN_QUERY_LEN: FILTER_QUERY_MIN_LEN,
       FILTER_ANCESTOR_DEPTH: FILTER_ANCESTOR_WALK_DEPTH,
+      HCLIP_ANCESTOR_DEPTH: HCLIP_ANCESTOR_WALK_DEPTH,
       MODAL_FRAMEWORK_SELECTORS: MODAL_V2_FRAMEWORK_SELECTORS,
       MODAL_CLASS_PATTERNS: MODAL_V2_CLASS_PATTERNS
     };
@@ -26970,6 +27073,15 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
       if (opts.v2 && r2.testId) {
         lines[i2] = appendAttributeIfMissing(lines[i2], "~test-id", encodeV2Value(r2.testId));
       }
+      if (opts.v2 && r2.dataId) {
+        lines[i2] = appendAttributeIfMissing(lines[i2], "~data-id", encodeV2Value(r2.dataId));
+      }
+      if (opts.v2 && r2.dataField) {
+        lines[i2] = appendAttributeIfMissing(lines[i2], "~field", encodeV2Value(r2.dataField.field));
+        if (r2.dataField.editable) {
+          lines[i2] = appendAttributeIfMissing(lines[i2], "~editable", "true");
+        }
+      }
       if (r2.editability) {
         if (r2.editability.readonly) {
           lines[i2] = appendAttributeIfMissing(lines[i2], "readonly", "true");
@@ -26978,6 +27090,9 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
           lines[i2] = appendAttributeIfMissing(lines[i2], "disabled", "true");
         }
       }
+      if (r2.hclip) {
+        lines[i2] = appendAttributeIfMissing(lines[i2], "~hclip", r2.hclip);
+      }
       if (r2.gridCellValue) {
         const escaped = r2.gridCellValue.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
         lines[i2] = appendValueTail(lines[i2], escaped);
@@ -38614,7 +38729,19 @@ function extractGridCell(cellEl) {
         ref: cellEl.ref,
         column: cellEl.text || "",
         value: textValue,
-        hasValue: true
+        hasValue: true,
+        dataField: cellEl.dataField,
+        isEditable: cellEl.isEditable
+      };
+    }
+    if (cellEl.isEditable && cellEl.ref) {
+      return {
+        ref: cellEl.ref,
+        column: "",
+        value: "",
+        hasValue: false,
+        dataField: cellEl.dataField,
+        isEditable: true
       };
     }
     return null;
@@ -38642,7 +38769,9 @@ function extractGridCell(cellEl) {
     value,
     hasValue: value !== "",
     gridcellLabel: gridcellLabel || void 0,
-    role
+    role,
+    dataField: cellEl.dataField,
+    isEditable: cellEl.isEditable
   };
 }
 function reconcileCellColumn(cell, knownColumns) {
@@ -38956,7 +39085,7 @@ function formatGridOutput(grid, indent, expanded = false) {
   const MAX_GRID_ROWS = 30;
   const displayRows = expanded ? grid.rows : grid.rows.slice(0, MAX_GRID_ROWS);
   for (const row of displayRows) {
-    lines.push(formatGridRow(row, indent + 1, knownColumns));
+    lines.push(formatGridRow(row, indent + 1, knownColumns, expanded));
   }
   if (!expanded && grid.rows.length > MAX_GRID_ROWS) {
     lines.push(
@@ -38965,7 +39094,8 @@ function formatGridOutput(grid, indent, expanded = false) {
   }
   return lines.join("\n");
 }
-function formatGridRow(row, indent, knownColumns) {
+var MAX_COMPACT_EDITABLE_CELLS_PER_ROW = 4;
+function formatGridRow(row, indent, knownColumns, expanded = false) {
   const indentStr = "  ".repeat(indent);
   if (row.expandedContent) {
     const parts = [];
@@ -38980,17 +39110,29 @@ function formatGridRow(row, indent, knownColumns) {
   const marker = row.isSelected ? "ACTIVE \u2192 Row" : "Row";
   const label = row.label ? ` "${row.label}"` : "";
   const actionsPrefix = row.rowActions?.length ? row.rowActions.map((a2) => `[action ${a2.ref}: ${a2.label}]`).join(" ") + " " : "";
-  const cellsWithValue = row.cells.filter(
-    (c3) => c3.hasValue && (!knownColumns || knownColumns.has(c3.column))
-  );
-  if (cellsWithValue.length > 0) {
-    const cellStrs = cellsWithValue.map((c3) => {
+  const inScope = (c3) => !knownColumns || knownColumns.has(c3.column);
+  const valueCells = row.cells.filter((c3) => c3.hasValue && inScope(c3));
+  const editableEmptyCells = row.cells.filter((c3) => !c3.hasValue && c3.isEditable && inScope(c3));
+  if (valueCells.length > 0 || editableEmptyCells.length > 0) {
+    const renderCell = (c3) => {
+      if (!c3.hasValue && c3.isEditable) {
+        return `${c3.column} [${c3.ref}]: (editable)`;
+      }
       if (c3.column === c3.value) {
         return `${c3.column} [${c3.ref}]`;
       }
       return `${c3.column} [${c3.ref}]: ${c3.value}`;
-    });
-    return `${indentStr}${actionsPrefix}${marker} [${row.ref}]${label}: ${cellStrs.join(" | ")}`;
+    };
+    const cellStrs = valueCells.map(renderCell);
+    const shownEditable = expanded ? editableEmptyCells : editableEmptyCells.slice(0, MAX_COMPACT_EDITABLE_CELLS_PER_ROW);
+    cellStrs.push(...shownEditable.map(renderCell));
+    const hiddenEditable = editableEmptyCells.length - shownEditable.length;
+    if (hiddenEditable > 0) {
+      cellStrs.push(`(+${hiddenEditable} more editable cells)`);
+    }
+    if (cellStrs.length > 0) {
+      return `${indentStr}${actionsPrefix}${marker} [${row.ref}]${label}: ${cellStrs.join(" | ")}`;
+    }
   }
   return `${indentStr}${actionsPrefix}${marker} [${row.ref}]${label}: (empty row)`;
 }
@@ -40380,9 +40522,6 @@ function isMeaningfulDisabledControlWithoutRef(element) {
   if (!label || label === element.role || label === "(icon)") return false;
   return true;
 }
-function isVolatileTestId(id) {
-  return /[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i.test(id) || /\b[0-9A-HJKMNP-TV-Z]{26}\b/.test(id) || /\b\d{6,}\b/.test(id);
-}
 function hasUsefulRenderLabel(label, role) {
   const trimmed = label.trim();
   return Boolean(trimmed && trimmed !== role && trimmed !== "(icon)" && trimmed !== "(no label)");
@@ -40395,7 +40534,7 @@ function renderableTestIdAttributes(element, label) {
   const uniqueStableIds = [];
   for (const id of testIds) {
     const trimmed = id.trim();
-    if (!trimmed || trimmed.length > 80 || isVolatileTestId(trimmed)) continue;
+    if (!trimmed || trimmed.length > 80 || isVolatileIdentifier(trimmed)) continue;
     if (!uniqueStableIds.includes(trimmed)) uniqueStableIds.push(trimmed);
   }
   return uniqueStableIds.slice(0, 2).map((id) => `testid=${id}`);
@@ -41686,10 +41825,7 @@ function formatSemanticSnapshot(yaml, options) {
       lines.push("");
     }
   }
-  let result = lines.join("\n").trim();
-  if (options?.offScreenRefs && options.offScreenRefs.size > 0) {
-    result = markOffScreenElements(result, options.offScreenRefs);
-  }
+  const result = lines.join("\n").trim();
   return result;
 }
 function expandSection(yaml, sectionRef) {
@@ -41764,15 +41900,6 @@ Section with ref="${sectionRef}" not found in snapshot.
   targetSection.collapsed = false;
   return formatExpandedSectionOutput(targetSection);
 }
-function markOffScreenElements(text, offScreenRefs) {
-  if (offScreenRefs.size === 0) return text;
-  return text.replace(/\[(e\d+)\](?! \[off-screen\])/g, (match, ref) => {
-    if (offScreenRefs.has(ref)) {
-      return `[${ref}] [off-screen]`;
-    }
-    return match;
-  });
-}
 function identifyLargeGridRefs(yaml, preParsedElements) {
   if (!yaml || yaml.trim() === "") return [];
   const elements = preParsedElements ?? parseSnapshot(yaml);
@@ -41943,6 +42070,15 @@ var INTERACTIVE_ROLES2 = /* @__PURE__ */ new Set([
   "listbox"
 ]);
 var DIALOG_ROLES2 = /* @__PURE__ */ new Set(["dialog", "alertdialog"]);
+var CONTENT_ROLES = /* @__PURE__ */ new Set([
+  "text",
+  "paragraph",
+  "heading",
+  "alert",
+  "status",
+  "note"
+]);
+var ALERT_ROLES = /* @__PURE__ */ new Set(["alert", "status"]);
 function extractElementState(el) {
   return {
     ref: el.ref,
@@ -41981,6 +42117,8 @@ function captureSnapshotState(url, yaml) {
   const editingContexts = extractEditingContextsFromElements(elements);
   const elementsByRef = /* @__PURE__ */ new Map();
   const interactiveRefs = /* @__PURE__ */ new Set();
+  const contentTexts = /* @__PURE__ */ new Set();
+  const alertTexts = /* @__PURE__ */ new Set();
   function traverse(el) {
     if (el.ref) {
       const state = extractElementState(el);
@@ -41989,6 +42127,13 @@ function captureSnapshotState(url, yaml) {
         interactiveRefs.add(el.ref);
       }
     }
+    const text = el.text?.trim();
+    if (text && CONTENT_ROLES.has(el.role)) {
+      contentTexts.add(text);
+      if (ALERT_ROLES.has(el.role)) {
+        alertTexts.add(text);
+      }
+    }
     for (const child of el.children) {
       traverse(child);
     }
@@ -42004,9 +42149,16 @@ function captureSnapshotState(url, yaml) {
     dialogStack,
     editingContexts,
     elementsByRef,
-    interactiveRefs
+    interactiveRefs,
+    contentTexts,
+    alertTexts
   };
 }
+function added(before, after) {
+  const out = [];
+  for (const t2 of after) if (!before.has(t2)) out.push(t2);
+  return out;
+}
 function compareSnapshots(before, after) {
   const urlChange = before.url !== after.url ? { before: before.url, after: after.url, navigated: true } : null;
   const beforeActive = before.activeElement ? extractElementState(before.activeElement) : null;
@@ -42092,6 +42244,10 @@ function compareSnapshots(before, after) {
     before.editingContexts,
     after.editingContexts
   );
+  const addedTexts = added(before.contentTexts, after.contentTexts);
+  const removedTexts = added(after.contentTexts, before.contentTexts);
+  const newAlerts = added(before.alertTexts, after.alertTexts);
+  const contentChange = addedTexts.length > 0 || removedTexts.length > 0 || newAlerts.length > 0 ? { addedTexts, removedTexts, newAlerts } : null;
   return {
     urlChange,
     activeChange,
@@ -42100,11 +42256,35 @@ function compareSnapshots(before, after) {
     removedElements,
     stateChanges,
     editingContextChanges,
+    contentChange,
     elementCountDelta
   };
 }
+function classifyScreenshotWorthiness(diff2, opts) {
+  const structuralThreshold = opts?.structuralThreshold ?? 8;
+  const contentThreshold = opts?.contentThreshold ?? 3;
+  if (diff2.urlChange?.navigated) {
+    return { warranted: true, reason: "navigation" };
+  }
+  if (diff2.dialogStackChange && diff2.dialogStackChange.after.length > diff2.dialogStackChange.before.length) {
+    return { warranted: true, reason: "dialog-opened" };
+  }
+  const structuralDelta = diff2.newElements.length + diff2.removedElements.length;
+  if (structuralDelta > structuralThreshold) {
+    return { warranted: true, reason: "structural-change" };
+  }
+  if (diff2.contentChange) {
+    if (diff2.contentChange.newAlerts.length > 0) {
+      return { warranted: true, reason: "new-alert" };
+    }
+    if (diff2.contentChange.addedTexts.length > contentThreshold) {
+      return { warranted: true, reason: "new-content" };
+    }
+  }
+  return { warranted: false };
+}
 function hasDiffChanges(diff2) {
-  return diff2.urlChange !== null || diff2.activeChange !== null || diff2.dialogStackChange !== null || diff2.newElements.length > 0 || diff2.removedElements.length > 0 || diff2.stateChanges.length > 0 || diff2.editingContextChanges.length > 0;
+  return diff2.urlChange !== null || diff2.activeChange !== null || diff2.dialogStackChange !== null || diff2.newElements.length > 0 || diff2.removedElements.length > 0 || diff2.stateChanges.length > 0 || diff2.editingContextChanges.length > 0 || diff2.contentChange !== null;
 }
 function formatElementBrief(el) {
   if (!el) return "none";
@@ -42214,7 +42394,7 @@ function formatSemanticDiff(diff2, actionDescription, networkInfo, currentTime)
     const after = diff2.dialogStackChange.after.length > 0 ? diff2.dialogStackChange.after.join(" -> ") : "(none)";
     lines.push(`DIALOGS: [PREVIOUS] ${before} [CURRENT] ${after}`);
   }
-  const hasChanges = diff2.newElements.length > 0 || diff2.removedElements.length > 0 || diff2.stateChanges.length > 0 || diff2.editingContextChanges.length > 0;
+  const hasChanges = diff2.newElements.length > 0 || diff2.removedElements.length > 0 || diff2.stateChanges.length > 0 || diff2.editingContextChanges.length > 0 || diff2.contentChange !== null;
   if (hasChanges) {
     lines.push("");
     lines.push("CHANGES DETECTED:");
@@ -42258,6 +42438,25 @@ function formatSemanticDiff(diff2, actionDescription, networkInfo, currentTime)
         `  - REMOVED: ${removedToShow.map((e2) => `${e2.role} "${truncate(e2.text, 15)}" [${e2.ref}]`).join(", ")}${moreText}`
       );
     }
+    if (diff2.contentChange) {
+      for (const alert of diff2.contentChange.newAlerts.slice(0, 5)) {
+        lines.push(`  - NEW ALERT: "${truncate(alert, 80)}"`);
+      }
+      const addedToShow = diff2.contentChange.addedTexts.filter((t2) => !diff2.contentChange.newAlerts.includes(t2)).slice(0, 5);
+      if (addedToShow.length > 0) {
+        const moreCount = diff2.contentChange.addedTexts.length - diff2.contentChange.newAlerts.length - addedToShow.length;
+        const moreText = moreCount > 0 ? ` (+${moreCount} more)` : "";
+        lines.push(`  - CONTENT: + ${addedToShow.map((t2) => `"${truncate(t2, 60)}"`).join(", ")}${moreText}`);
+      }
+      const removedToShow2 = diff2.contentChange.removedTexts.slice(0, 5);
+      if (removedToShow2.length > 0) {
+        const moreCount = diff2.contentChange.removedTexts.length - removedToShow2.length;
+        const moreText = moreCount > 0 ? ` (+${moreCount} more)` : "";
+        lines.push(
+          `  - CONTENT: - ${removedToShow2.map((t2) => `"${truncate(t2, 60)}"`).join(", ")}${moreText}`
+        );
+      }
+    }
   }
   if (diff2.elementCountDelta !== 0) {
     const sign = diff2.elementCountDelta > 0 ? "+" : "";
@@ -42825,13 +43024,21 @@ function extractFormattedSnapshotRefs(text) {
   }
   return [...refs];
 }
-function markOffScreenRefsInText(text, offScreenRefs) {
-  if (offScreenRefs.size === 0) return text;
-  return text.replace(/\[(e\d+)\](?! \[off-screen\])/g, (match, ref) => {
-    if (offScreenRefs.has(ref)) {
-      return `[${ref}] [off-screen]`;
-    }
-    return match;
+function parseHorizontalScrollRefs(yaml) {
+  const byRef = /* @__PURE__ */ new Map();
+  for (const line of yaml.split("\n")) {
+    const refMatch = line.match(/\[ref=(e\d+)\]/);
+    if (!refMatch) continue;
+    const dirMatch = line.match(/~hclip=(left|right)\b/);
+    if (dirMatch) byRef.set(refMatch[1], dirMatch[1]);
+  }
+  return byRef;
+}
+function markHorizontalScrollRefsInText(text, byRef) {
+  if (byRef.size === 0) return text;
+  return text.replace(/\[(e\d+)\](?! \[scroll-(?:left|right)\])/g, (match, ref) => {
+    const dir = byRef.get(ref);
+    return dir ? `[${ref}] [scroll-${dir}]` : match;
   });
 }
 var BrowserToolExecutor = class {
@@ -42851,12 +43058,20 @@ var BrowserToolExecutor = class {
    * call share one allocation instead of calling `combineSignals` each time.
    */
   cachedCombinedSignal;
+  /**
+   * In-flight forced page-recovery kicked off when a tool call's per-tool
+   * timeout fired on a wedged page. The NEXT `withCallSignal` awaits it before
+   * running, so the next action starts on a fresh, re-navigated page instead of
+   * issuing another orphaning op against the frozen renderer.
+   */
+  recoveryInFlight;
   onScreenshot;
   maxImageDimension;
   clickValidation;
   allowedHosts;
   autoSnapshotAfterAction;
   includeScreenshotWithSnapshot;
+  liveSnapshotEnabled;
   workspaceDir;
   logger;
   spanFactory;
@@ -42896,6 +43111,9 @@ var BrowserToolExecutor = class {
     this.allowedHosts = options?.allowedHosts;
     this.autoSnapshotAfterAction = options?.autoSnapshotAfterAction !== false;
     this.includeScreenshotWithSnapshot = options?.includeScreenshotWithSnapshot !== false;
+    this.liveSnapshotEnabled = options?.liveSnapshot === true;
+    this.client.setLiveSnapshotEnabled?.(this.liveSnapshotEnabled);
+    this.client.setLiveSnapshotRawOnMiss?.(options?.liveSnapshotRawOnMiss === true);
     if (!options?.workspaceDir && !options?.tmpBaseDir) {
       options?.logger?.debug?.(
         "[BrowserToolExecutor] No tmpBaseDir provided, using flat canary dir (not org-scoped)"
@@ -42993,6 +43211,12 @@ var BrowserToolExecutor = class {
         "[BrowserToolExecutor] withCallSignal invoked while another per-call signal was already active. Concurrent tool calls on a single executor are not supported \u2014 verify the session gate is in place."
       );
     }
+    if (this.recoveryInFlight) {
+      const pending = this.recoveryInFlight;
+      this.recoveryInFlight = void 0;
+      await pending.catch(() => {
+      });
+    }
     const prev = this.callSignal;
     const prevCached = this.cachedCombinedSignal;
     this.callSignal = signal;
@@ -43007,6 +43231,7 @@ var BrowserToolExecutor = class {
           error: err instanceof Error ? err.message : String(err)
         });
       }
+      this.scheduleForceRecover("tool_timeout");
     };
     if (signal?.aborted) {
       fireUnwedge();
@@ -43033,6 +43258,56 @@ var BrowserToolExecutor = class {
       if (onAbort && signal) signal.removeEventListener("abort", onAbort);
     }
   }
+  /**
+   * Schedule a liveness-gated forced recovery, CHAINING onto any already-pending
+   * one. Two triggers can fire within a single tool call — the per-tool abort
+   * (`withCallSignal`) and the post-action snapshot timeout — so a bare
+   * assignment would clobber the first (leaving it unawaited) and double-probe.
+   * Chaining makes the next `withCallSignal` await the whole sequence and keeps
+   * the probes serial. This is the single owner of `recoveryInFlight`.
+   */
+  scheduleForceRecover(reason) {
+    this.recoveryInFlight = (this.recoveryInFlight ?? Promise.resolve()).then(
+      () => this.maybeForceRecover(reason)
+    );
+  }
+  /**
+   * Liveness-gated forced recovery. Probes whether the page's main thread is
+   * responsive; only tears it down when it is genuinely wedged, so a
+   * slow-but-progressing page is spared (its orphan settles on its own and the
+   * abort-gated re-checks elsewhere prevent it from corrupting state). Never
+   * throws — recovery is best-effort.
+   */
+  async maybeForceRecover(reason) {
+    const client = this.client;
+    if (typeof client.probeLiveness !== "function" || typeof client.forceRecoverPage !== "function") {
+      return;
+    }
+    try {
+      const liveness = await client.probeLiveness();
+      if (liveness === "alive") {
+        this.logger?.info?.(
+          "[BrowserToolExecutor] page alive after tool timeout; sparing it (no forced recovery)"
+        );
+        return;
+      }
+      this.logger?.warn?.(
+        liveness === "closed" ? "[BrowserToolExecutor] page already closed after tool timeout; recreating" : "[BrowserToolExecutor] page unresponsive after tool timeout; forcing page recovery",
+        { liveness, reason }
+      );
+      const recovered = await client.forceRecoverPage(reason);
+      if (!recovered) {
+        this.logger?.warn?.(
+          "[BrowserToolExecutor] forced recovery did not yield a live page; next action may fail",
+          { liveness, reason }
+        );
+      }
+    } catch (err) {
+      this.logger?.warn?.("[BrowserToolExecutor] forced recovery failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   // ==================== Navigation ====================
   async navigate(url) {
     ensureAllowedHost(url, this.allowedHosts);
@@ -43239,32 +43514,15 @@ ${effectiveShowCoordinateGrid ? "Coordinate grid enabled - read coordinates from
       matchedHintIds: void 0
     };
     let semanticText = formatSemanticSnapshot(yaml, snapshotOpts);
-    try {
-      const formattedRefs = extractFormattedSnapshotRefs(semanticText);
-      const offScreenRefs = await this.traced("offscreen_detection", "off-screen element scan", async () => {
-        if (!this.client.getElementBoundingBoxes || formattedRefs.length === 0) return void 0;
-        const boxes = await this.client.getElementBoundingBoxes(formattedRefs, {
-          signal: this.currentSignal
-        });
-        const { width: vw, height: vh } = this.client.getViewportSize();
-        const offscreen = /* @__PURE__ */ new Set();
-        for (const [ref, box] of boxes) {
-          if (box.width === 0 && box.height === 0) continue;
-          const right = box.x + box.width;
-          const bottom = box.y + box.height;
-          if (right < 0 || box.x > vw || bottom < 0 || box.y > vh) {
-            offscreen.add(ref);
-          }
-        }
-        return offscreen.size > 0 ? offscreen : void 0;
-      });
-      if (offScreenRefs) {
-        semanticText = markOffScreenRefsInText(semanticText, offScreenRefs);
+    const formattedRefs = extractFormattedSnapshotRefs(semanticText);
+    if (formattedRefs.length > LARGE_PAGE_REF_THRESHOLD) {
+      semanticText = `[Large page: ~${formattedRefs.length.toLocaleString()} interactive elements \u2014 scroll-position hints reduced for speed. Narrow with browser_snapshot search=\u2026 or scroll to a region.]
+` + semanticText;
+    } else {
+      const hScrollRefs = parseHorizontalScrollRefs(yaml);
+      if (hScrollRefs.size > 0) {
+        semanticText = markHorizontalScrollRefsInText(semanticText, hScrollRefs);
       }
-    } catch (e2) {
-      this.logger?.debug?.("[browser_snapshot] Off-screen detection failed", {
-        error: e2 instanceof Error ? e2.message : String(e2)
-      });
     }
     if (snapshotOpts.matchedHintIds && snapshotOpts.matchedHintIds.length > 0 && this.hintProvider) {
       this.hintProvider.recordMatches(snapshotOpts.matchedHintIds).catch(() => {
@@ -43812,11 +44070,14 @@ ${header}
     const autoEnabled = this.autoSnapshotAfterAction;
     const includeScreenshot = this.includeScreenshotWithSnapshot;
     const beforeUrl = await this.client.getCurrentUrl();
-    const beforeResult = await this.client.snapshot({ signal: this.currentSignal, mode: "tree" });
-    const beforeYaml = extractSnapshotYaml(beforeResult);
+    let beforeYaml = this.liveSnapshotEnabled ? await this.client.getReusableSnapshotYaml?.() ?? null : null;
+    if (beforeYaml === null) {
+      const beforeResult = await this.client.snapshot({ signal: this.currentSignal, mode: "tree" });
+      beforeYaml = extractSnapshotYaml(beforeResult);
+    }
     const beforeState = captureSnapshotState(beforeUrl, beforeYaml);
     const actionResult = await action();
-    const afterMode = autoEnabled && includeScreenshot ? "both" : "tree";
+    const afterMode = !this.liveSnapshotEnabled && autoEnabled && includeScreenshot ? "both" : "tree";
     let afterUrl = beforeUrl;
     let afterResult = "";
     let afterYaml = "";
@@ -43902,6 +44163,7 @@ ${header}
     }
     if (snapshotTimedOut) {
       this.consecutiveSnapshotTimeouts += 1;
+      this.scheduleForceRecover("post_action_snapshot_timeout");
       const now2 = (/* @__PURE__ */ new Date()).toISOString();
       const baseDiff = formatSemanticDiff(
         compareSnapshots(beforeState, beforeState),
@@ -43966,7 +44228,31 @@ ${recoveryHint}`;
           consoleErrors: this.client.getNewConsoleErrors?.() ?? [],
           failedRequests: this.client.getNewFailedRequests?.() ?? []
         });
-        const afterImages = isMCPContentWithImages(afterResult) ? afterResult.images : void 0;
+        let afterImages;
+        let withheldNote;
+        if (this.liveSnapshotEnabled) {
+          if (includeScreenshot) {
+            const worthiness = classifyScreenshotWorthiness(diff2);
+            if (worthiness.warranted) {
+              try {
+                const shot = await this.client.snapshot({
+                  signal: this.currentSignal,
+                  mode: "screenshot",
+                  maxImageDimension: this.maxImageDimension
+                });
+                afterImages = isMCPContentWithImages(shot) ? shot.images : void 0;
+              } catch (e2) {
+                this.logger?.warn?.("[withSemanticDiff] On-demand screenshot failed", {
+                  error: e2 instanceof Error ? e2.message : String(e2)
+                });
+              }
+            } else {
+              withheldNote = "IMAGE: withheld \u2014 no visual-orienting change (input/focus/state-only). Call browser_screenshot or browser_snapshot mode:'both' for a full image.";
+            }
+          }
+        } else {
+          afterImages = isMCPContentWithImages(afterResult) ? afterResult.images : void 0;
+        }
         if (afterImages?.length && this.onScreenshot) {
           const img = afterImages[0];
           await this.onScreenshot(`data:${img.mimeType};base64,${img.data}`, "auto-snapshot");
@@ -43979,6 +44265,9 @@ ${recoveryHint}`;
             this.logger
           );
           snapshotText = resolutionNote + "\n" + semanticText;
+        } else if (withheldNote) {
+          snapshotText = `${withheldNote}
+${semanticText}`;
         }
         autoSnapshot = {
           text: snapshotText,
@@ -43990,6 +44279,7 @@ ${recoveryHint}`;
         });
       }
     }
+    this.client.warmSnapshot?.();
     return { diffText, actionResult, autoSnapshot };
   }
   /**
@@ -44348,7 +44638,7 @@ function getBrowserToolDefinitions() {
           },
           toRef: {
             type: "string",
-            description: "Scroll the page so this element is centered in the viewport. Handles both vertical and horizontal scrolling automatically \u2014 works for grid columns that are horizontally off-screen."
+            description: "Scroll the page so this element is centered in the viewport. Handles both vertical and horizontal scrolling automatically \u2014 works for grid columns that are horizontally off-screen. A ref marked [scroll-left]/[scroll-right] in the snapshot is clipped inside a horizontal scroll container; pass it here to bring it into view."
           },
           x: {
             type: "number",
@@ -47302,6 +47592,290 @@ async function augmentBlockingModalSignal(page, yaml, logger2, preParsedElements
   }
 }
 
+// ../browser-core/src/playwright-client/dom-revision-script.ts
+var DOM_REVISION_SCRIPT = `
+(() => {
+  if (window.__domRevisionInstalled) return;
+  window.__domRevisionInstalled = true;
+  window.__domRevision = 0;
+  window.__lastMutationTs = (typeof performance !== 'undefined' && performance.now)
+    ? performance.now()
+    : Date.now();
+
+  var now = function () {
+    return (typeof performance !== 'undefined' && performance.now)
+      ? performance.now()
+      : Date.now();
+  };
+
+  var bump = function () {
+    window.__domRevision = (window.__domRevision || 0) + 1;
+    window.__lastMutationTs = now();
+  };
+
+  var install = function () {
+    try {
+      // Observe the Document node itself (not documentElement): it survives
+      // document.open()/write() \u2014 which replaces documentElement and would
+      // orphan an observer attached to it \u2014 while subtree:true still catches
+      // every descendant childList/attribute/text mutation.
+      var observer = new MutationObserver(bump);
+      observer.observe(document, {
+        childList: true,
+        attributes: true,
+        characterData: true,
+        subtree: true,
+      });
+      window.__domRevisionObserver = observer;
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+
+  if (!install()) {
+    document.addEventListener('DOMContentLoaded', install, { once: true });
+  }
+
+  // Input/focus activity doesn't always fire a mutation (typing sets the .value
+  // property), but it IS "the page is changing" for settle purposes \u2014 so count
+  // it toward __lastMutationTs. Capture phase on window so it survives document
+  // replacement and catches events from inside shadow DOM (they're composed).
+  window.addEventListener('input', bump, true);
+  window.addEventListener('change', bump, true);
+  window.addEventListener('focusin', bump, true);
+  window.addEventListener('focusout', bump, true);
+
+  // Resolves when the DOM has been quiet (no mutations / input) for quietMs, or
+  // after maxWaitMs elapses \u2014 whichever comes first. Event-driven (no polling):
+  // a single timer is (re)scheduled off __lastMutationTs.
+  window.__waitDomQuiet = function (quietMs, maxWaitMs) {
+    quietMs = typeof quietMs === 'number' ? quietMs : 100;
+    maxWaitMs = typeof maxWaitMs === 'number' ? maxWaitMs : 2000;
+    return new Promise(function (resolve) {
+      var start = now();
+      var timer = null;
+      var done = false;
+
+      var finish = function (reason) {
+        if (done) return;
+        done = true;
+        if (timer) clearTimeout(timer);
+        resolve(reason);
+      };
+
+      var schedule = function () {
+        if (done) return;
+        var sinceMutation = now() - (window.__lastMutationTs || 0);
+        var sinceStart = now() - start;
+        // Hard cap: never block past maxWaitMs (streaming/websocket pages).
+        if (sinceStart >= maxWaitMs) {
+          finish('maxwait');
+          return;
+        }
+        if (sinceMutation >= quietMs) {
+          finish('quiet');
+          return;
+        }
+        // Wait for the shorter of "quiet window remaining" / "maxwait remaining",
+        // then re-check (a mutation may have landed since, moving __lastMutationTs).
+        var waitForQuiet = quietMs - sinceMutation;
+        var waitForCap = maxWaitMs - sinceStart;
+        timer = setTimeout(schedule, Math.max(0, Math.min(waitForQuiet, waitForCap)));
+      };
+
+      schedule();
+    });
+  };
+})();
+`;
+
+// ../browser-core/src/playwright-client/evaluate-with-cap.ts
+var EVALUATE_CAPPED = /* @__PURE__ */ Symbol("browser-core.evaluate-capped");
+async function evaluateWithCap(capMs, op) {
+  let timer;
+  let capped = false;
+  const cap = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      capped = true;
+      resolve(EVALUATE_CAPPED);
+    }, capMs);
+  });
+  const evaluation = op().catch(
+    (err) => {
+      if (capped) return EVALUATE_CAPPED;
+      throw err;
+    }
+  );
+  try {
+    return await Promise.race([evaluation, cap]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// ../browser-core/src/playwright-client/http-settle.ts
+var STREAM_RESOURCE_TYPES = /* @__PURE__ */ new Set(["eventsource", "websocket"]);
+function countUnsettledRequests(requests, now, opts) {
+  let n2 = 0;
+  for (const req of requests) {
+    if (req.status !== "pending") continue;
+    if (req.resourceType !== void 0 && STREAM_RESOURCE_TYPES.has(req.resourceType)) continue;
+    if (opts.noisePatterns.some((p2) => p2.test(req.url))) continue;
+    if (req.startedAt !== void 0 && now - req.startedAt > opts.maxAgeMs) continue;
+    n2++;
+  }
+  return n2;
+}
+
+// ../browser-core/src/playwright-client/liveness-probe.ts
+var Liveness = {
+  Alive: "alive",
+  Unresponsive: "unresponsive",
+  Closed: "closed"
+};
+var CLOSURE_HINTS = [
+  "target closed",
+  "has been closed",
+  "browser has been closed",
+  "execution context was destroyed",
+  "browser closed",
+  "context closed"
+];
+function looksClosed(err) {
+  const message = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return CLOSURE_HINTS.some((h) => message.includes(h));
+}
+async function probePageLiveness(page, capMs) {
+  if (!page || page.isClosed()) return Liveness.Closed;
+  try {
+    const result = await evaluateWithCap(capMs, () => page.evaluate(() => 1));
+    if (result === EVALUATE_CAPPED) return Liveness.Unresponsive;
+    return Liveness.Alive;
+  } catch (err) {
+    return looksClosed(err) ? Liveness.Closed : Liveness.Unresponsive;
+  }
+}
+
+// ../browser-core/src/live-snapshot.ts
+function mintedYaml(snap) {
+  return snap.augmentedYaml ?? snap.rawYaml;
+}
+var LiveSnapshotManager = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+  }
+  deps;
+  current = null;
+  generationCounter = 0;
+  /** Serializes captures so two never run against the page at once. */
+  chain = Promise.resolve();
+  now;
+  /** The current mint without re-checking the live page (may be stale). */
+  peek() {
+    return this.current;
+  }
+  /** Drop the cached snapshot (e.g. on navigation / new page). */
+  reset() {
+    this.current = null;
+  }
+  /** Run `fn` after any in-flight capture settles; never overlap captures. */
+  enqueue(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  /**
+   * Produce a current snapshot, reusing the augmented one when the raw substrate
+   * is unchanged. Always takes a fresh (cheap) raw substrate first, so it never
+   * serves a stale representation.
+   */
+  mint(opts) {
+    return this.enqueue(() => this.doMint(opts));
+  }
+  async doMint(opts) {
+    const raw = await this.deps.captureRaw(opts?.signal);
+    if (!raw) {
+      if (this.current) return this.current;
+      throw new Error("[LiveSnapshot] captureRaw returned null and there is no current snapshot");
+    }
+    if (!opts?.force && this.current && this.current.augmentedYaml !== null && this.current.rawYaml === raw.rawYaml) {
+      return this.current;
+    }
+    if (opts?.rawOnMiss) {
+      const snap = this.store(raw.url, raw.rawYaml, null);
+      this.scheduleAugment(snap, opts?.signal);
+      return snap;
+    }
+    const augmentedYaml = await this.deps.augment(raw.rawYaml, opts?.signal);
+    return this.store(raw.url, raw.rawYaml, augmentedYaml);
+  }
+  store(url, rawYaml, augmentedYaml) {
+    const snap = {
+      generation: ++this.generationCounter,
+      url,
+      rawYaml,
+      augmentedYaml,
+      capturedAtMs: this.now()
+    };
+    this.current = snap;
+    return snap;
+  }
+  /** Background-augment a raw-only mint, upgrading `current` in place if still current. */
+  scheduleAugment(snap, signal) {
+    void this.enqueue(async () => {
+      if (this.current !== snap) return;
+      try {
+        const augmentedYaml = await this.deps.augment(snap.rawYaml, signal);
+        if (this.current === snap) {
+          this.current = { ...snap, augmentedYaml };
+        }
+      } catch (err) {
+        this.deps.logger?.debug?.("[LiveSnapshot] background augment failed (ignored)", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }).catch(() => void 0);
+  }
+  /**
+   * Return the current AUGMENTED snapshot if its raw substrate still matches the
+   * live page, else null — used to reuse the warm snapshot as a diff baseline.
+   * Takes a fresh (cheap) raw substrate to verify; never augments.
+   */
+  getReusable(opts) {
+    return this.enqueue(async () => {
+      if (!this.current || this.current.augmentedYaml === null) return null;
+      const raw = await this.deps.captureRaw(opts?.signal);
+      if (!raw) return null;
+      return raw.rawYaml === this.current.rawYaml ? this.current : null;
+    });
+  }
+  /**
+   * Fire-and-forget background refresh. Waits for the DOM to settle, then mints
+   * (reusing or augmenting) so the next request hits the reuse path. Errors are
+   * swallowed — warming must never surface to the agent.
+   */
+  warm(opts) {
+    void this.warmAsync(opts).catch((err) => {
+      this.deps.logger?.debug?.("[LiveSnapshot] warm failed (ignored)", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+  /** Test seam: the awaitable warm body. */
+  async warmAsync(opts) {
+    if (this.deps.waitQuiet) {
+      await this.deps.waitQuiet(opts?.quietMs ?? 100, opts?.maxWaitMs ?? 2e3);
+    }
+    if (opts?.signal?.aborted) return;
+    await this.mint({ signal: opts?.signal, rawOnMiss: opts?.rawOnMiss });
+  }
+};
+
 // ../browser-core/src/playwright-client/response-format.ts
 var TOAST_SNAPSHOT_TTL = 5;
 function formatMcpResponse(input) {
@@ -47565,6 +48139,7 @@ var PlaywrightClient = class _PlaywrightClient {
   screencastEncoderFactory;
   tmpBaseDir;
   spanFactory;
+  stabilizeDomMs;
   /** In-flight latch for `attemptUnwedgePage` so close-succession aborts
    *  don't dispatch redundant `window.stop()` evaluates. */
   unwedgeInFlight = false;
@@ -47572,6 +48147,7 @@ var PlaywrightClient = class _PlaywrightClient {
     this.browserLease = options?.browserLease ?? null;
     this.logger = options?.logger ?? consoleLogger;
     this.spanFactory = options?.spanFactory ?? null;
+    this.stabilizeDomMs = options?.stabilizeDomMs ?? TIMEOUTS.STABILIZE_DOM;
     this.screencastEncoderFactory = options?.screencastEncoderFactory ?? null;
     this.cursorOverlay = new CursorOverlay({ enabled: false });
     if (!options?.tmpBaseDir) {
@@ -47580,6 +48156,95 @@ var PlaywrightClient = class _PlaywrightClient {
       );
     }
     this.tmpBaseDir = options?.tmpBaseDir ?? getCanaryTmpDir();
+    this.liveSnapshot = new LiveSnapshotManager({
+      logger: this.logger,
+      // CHEAP tier: the raw substrate (the freshness ground truth).
+      captureRaw: async (signal) => {
+        const page = this.page;
+        if (!page || page.isClosed()) return null;
+        const rawYaml = await this.captureRawSubstrate(signal).catch(() => "");
+        if (signal?.aborted || !rawYaml) return null;
+        return { rawYaml, url: page.url() };
+      },
+      // EXPENSIVE tier: augment the raw substrate.
+      augment: (rawYaml, signal) => this.augmentSubstrate(rawYaml, signal),
+      waitQuiet: (quietMs, maxWaitMs) => this.waitDomQuiet(quietMs, maxWaitMs)
+    });
+  }
+  /** Enable/disable the live-snapshot (warm + minted) path. Off = legacy v1. */
+  setLiveSnapshotEnabled(enabled) {
+    this.liveSnapshotEnabled = enabled;
+  }
+  /**
+   * On a freshness miss, return the raw substrate immediately and augment in the
+   * background (instead of blocking). Default off → block on augmentation
+   * (matches legacy behavior and the snapshot formatter's expectations).
+   */
+  setLiveSnapshotRawOnMiss(rawOnMiss) {
+    this.liveSnapshotRawOnMiss = rawOnMiss;
+  }
+  /**
+   * Capture the accessibility-tree YAML, routing through the live-snapshot
+   * manager when enabled (raw substrate compared exactly; augmentation reused
+   * when unchanged). `force` re-augments unconditionally (used by navigation).
+   * Falls back to the legacy full capture when disabled.
+   */
+  captureTreeYaml(signal, opts) {
+    if (this.liveSnapshotEnabled) {
+      return this.liveSnapshot.mint({ signal, force: opts?.force, rawOnMiss: this.liveSnapshotRawOnMiss }).then((s2) => mintedYaml(s2));
+    }
+    return this.traced(
+      "snapshot_for_ai",
+      "capture accessibility tree",
+      () => this.captureSnapshotInternal(signal)
+    );
+  }
+  /**
+   * Wait until the DOM has been quiet for `quietMs` (bounded by `maxWaitMs`),
+   * using the page-side `__waitDomQuiet` helper. If the helper is missing or
+   * unreadable (init-script race, or a pre-existing CDP document), fall back to
+   * a fixed `quietMs` delay — NOT an immediate return, which would drop the
+   * stabilize wait and risk capturing a half-rendered SPA. Soft — never throws.
+   *
+   * The evaluate is bounded by a DRIVER-side race (`maxWaitMs` + grace): the
+   * in-page cap is a page-side setTimeout that never fires when the main
+   * thread is blocked, so without the race a single stalled page hangs this
+   * await forever and wedges every subsequent tool call (June 2026
+   * live-snapshot suite wedge). On cap we return immediately — the stabilize
+   * budget is already spent; stacking the quietMs fallback on top would only
+   * delay the caller further on a page that can't get healthier by waiting.
+   */
+  async waitDomQuiet(quietMs, maxWaitMs) {
+    const page = this.page;
+    if (!page || page.isClosed()) return;
+    let ran = false;
+    try {
+      const result = await evaluateWithCap(
+        maxWaitMs + TIMEOUTS.WAIT_DOM_QUIET_EVAL_GRACE,
+        () => page.evaluate(
+          async ({ q, m }) => {
+            const w = window;
+            if (typeof w.__waitDomQuiet !== "function") return false;
+            await w.__waitDomQuiet(q, m);
+            return true;
+          },
+          { q: quietMs, m: maxWaitMs }
+        )
+      );
+      if (result === EVALUATE_CAPPED) {
+        this.logger.warn(
+          "[DirectPlaywright] waitDomQuiet evaluate exceeded driver-side cap (page main thread may be blocked)",
+          { maxWaitMs, graceMs: TIMEOUTS.WAIT_DOM_QUIET_EVAL_GRACE }
+        );
+        return;
+      }
+      ran = result;
+    } catch {
+      ran = false;
+    }
+    if (!ran) {
+      await page.waitForTimeout(quietMs).catch(() => void 0);
+    }
   }
   /**
    * Race a Playwright op against `signal`:
@@ -47646,7 +48311,7 @@ var PlaywrightClient = class _PlaywrightClient {
     this.logger.info("[DirectPlaywright] attemptUnwedgePage dispatched");
     let timer;
     void Promise.race([
-      page.evaluate("window.stop()").then(() => this.logger.info("[DirectPlaywright] attemptUnwedgePage completed")).catch((err) => {
+      page.evaluate(() => window.stop()).then(() => this.logger.info("[DirectPlaywright] attemptUnwedgePage completed")).catch((err) => {
         this.logger.warn("[DirectPlaywright] attemptUnwedgePage evaluate failed", {
           error: err instanceof Error ? err.message : String(err)
         });
@@ -47665,6 +48330,65 @@ var PlaywrightClient = class _PlaywrightClient {
       this.unwedgeInFlight = false;
     });
   }
+  /**
+   * Cheap, driver-bounded liveness check (`page.evaluate(() => 1)` under a
+   * short cap). Used by the per-tool-timeout recovery path to decide whether a
+   * timed-out page is genuinely wedged (force-recover) or just slow (spare it).
+   */
+  async probeLiveness() {
+    return probePageLiveness(this.page, TIMEOUTS.LIVENESS_PROBE_CAP);
+  }
+  /**
+   * Force-recover the active page so orphaned Playwright ops die with the
+   * renderer. `ariaSnapshot`/`screenshot` have no timeout and cannot be
+   * cancelled; when the per-tool timeout fires they keep running for minutes on
+   * a jammed renderer. Closing the page rejects every in-flight op bound to its
+   * CDP session — the only thing that truly kills the orphans — then we recreate
+   * the page and re-navigate to `lastKnownUrl` via the existing crash-recovery
+   * path. Never throws; returns whether a live page is available afterward.
+   */
+  async forceRecoverPage(reason) {
+    if (this.pageClosedIntentionally) return false;
+    if (this.restoreInProgress && this.restorePromise) {
+      await this.restorePromise.catch(() => {
+      });
+      return !!this.page && !this.page.isClosed();
+    }
+    const startedAt = Date.now();
+    try {
+      const page = this.page;
+      if (page && !page.isClosed()) {
+        this.forcedTeardownInProgress = true;
+        try {
+          await this.withOperationTimeout(
+            page.close({ runBeforeUnload: false }),
+            2e3,
+            "forceRecover:pageClose"
+          ).catch(() => {
+          });
+        } finally {
+          this.forcedTeardownInProgress = false;
+        }
+      }
+      this._pendingCrashUrl = this.lastKnownUrl;
+      this._pendingCrashType = "page_crash";
+      await this.restoreBrowser(reason);
+      const recovered = !!this.page && !this.page.isClosed();
+      this.logger.info("[DirectPlaywright] forceRecoverPage completed", {
+        reason,
+        recovered,
+        durationMs: Date.now() - startedAt,
+        restoredUrl: this.lastKnownUrl
+      });
+      return recovered;
+    } catch (err) {
+      this.logger.warn("[DirectPlaywright] forceRecoverPage failed", {
+        reason,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  }
   /**
    * Set the span factory for sub-operation tracing after construction.
    * Called by the API layer to propagate Sentry span context.
@@ -47710,12 +48434,20 @@ var PlaywrightClient = class _PlaywrightClient {
    * Used to guard against hung Playwright operations (launch, connect, newContext).
    */
   async withOperationTimeout(operation, timeoutMs, label) {
-    return Promise.race([
-      operation,
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
-      )
-    ]);
+    let timer;
+    try {
+      return await Promise.race([
+        operation,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
+            timeoutMs
+          );
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
   }
   isRecoverableClosureError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -47728,6 +48460,10 @@ var PlaywrightClient = class _PlaywrightClient {
   contextClosedIntentionally = false;
   lastConnectOptions = null;
   pageClosedIntentionally = false;
+  // Set while `forceRecoverPage` is deliberately closing the page so the
+  // page-close handler doesn't log it as an unexpected crash / re-stamp crash
+  // state. Distinct from `pageClosedIntentionally` (which makes getPage throw).
+  forcedTeardownInProgress = false;
   restoreInProgress = false;
   restorePromise = null;
   // State tracking (MCP does this internally via Tab class)
@@ -47748,6 +48484,11 @@ var PlaywrightClient = class _PlaywrightClient {
   // Last snapshot for reference (used by some methods)
   lastSnapshotYaml = "";
   lastSnapshotTimestamp = 0;
+  // Live-snapshot (warm/minted) state. Gated by `liveSnapshotEnabled`; when off,
+  // snapshot() behaves exactly as before. See live-snapshot.ts.
+  liveSnapshotEnabled = false;
+  liveSnapshotRawOnMiss = false;
+  liveSnapshot;
   // Last resolved element metadata (for recording layer to avoid snapshot re-parsing)
   lastResolvedElementMetadata = /* @__PURE__ */ new Map();
   // Tracing state
@@ -48554,7 +49295,7 @@ var PlaywrightClient = class _PlaywrightClient {
       this.highlightStylesInjected = false;
       this.cursorOverlay.resetInjectionState();
       const [snapshotYaml, title] = await Promise.all([
-        this.captureSnapshotInternal(opts?.signal),
+        this.captureTreeYaml(opts?.signal, { force: true }),
         this.getPage().then((p2) => p2.title())
       ]);
       return this.formatMCPResponse(
@@ -48576,7 +49317,7 @@ var PlaywrightClient = class _PlaywrightClient {
     this.highlightStylesInjected = false;
     this.cursorOverlay.resetInjectionState();
     const [snapshotYaml, title] = await Promise.all([
-      this.captureSnapshotInternal(opts?.signal),
+      this.captureTreeYaml(opts?.signal, { force: true }),
       this.getPage().then((p2) => p2.title())
     ]);
     return this.formatMCPResponse("Navigated back", snapshotYaml, "await page.goBack();", title);
@@ -48593,14 +49334,21 @@ var PlaywrightClient = class _PlaywrightClient {
     } else if (opts?.includeScreenshot) {
       effectiveMode = "both";
     }
-    await this.traced("stabilize", "DOM stabilize", () => this.stabilize("dom-only"));
+    await this.traced(
+      "stabilize",
+      "DOM stabilize",
+      () => this.stabilize("dom-only", opts?.signal)
+    );
     if (effectiveMode === "screenshot") {
       try {
         const title2 = await page.title();
         const buffer = await page.screenshot({
           type: "jpeg",
           quality: 90,
-          fullPage: false
+          fullPage: false,
+          // Hard cap: a screenshot blocks on a composited frame, which a jammed
+          // renderer can't produce — without a timeout it orphans for minutes.
+          timeout: TIMEOUTS.SCREENSHOT
         });
         const base64 = buffer.toString("base64");
         const downsampledBase642 = await downsampleImage(base64, opts?.maxImageDimension);
@@ -48622,26 +49370,41 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
         throw new Error("Failed to capture screenshot in screenshot-only mode");
       }
     }
-    const captureScreenshot = effectiveMode === "both" ? this.traced("screenshot", "capture + downsample screenshot", async () => {
-      const buffer = await page.screenshot({
-        type: "jpeg",
-        quality: 90,
-        fullPage: false
-      });
-      return downsampleImage(buffer.toString("base64"), opts?.maxImageDimension);
-    }).catch((err) => {
+    const captureScreenshot = effectiveMode === "both" ? this.traced(
+      "screenshot",
+      "capture + downsample screenshot",
+      () => (
+        // Raced against the tool signal AND given a hard Playwright timeout:
+        // a viewport screenshot still waits for a composited frame, which a
+        // jammed renderer can't hand back, so without both bounds it orphans
+        // for minutes behind the wedge.
+        this.raceAgainstSignal("snapshot:screenshot", opts?.signal, async () => {
+          const buffer = await page.screenshot({
+            type: "jpeg",
+            quality: 90,
+            fullPage: false,
+            timeout: TIMEOUTS.SCREENSHOT
+          });
+          return downsampleImage(buffer.toString("base64"), opts?.maxImageDimension);
+        })
+      )
+    ).catch((err) => {
       this.logger.warn("[DirectPlaywright] Failed to capture screenshot for snapshot", {
         error: err instanceof Error ? err.message : String(err)
       });
       return null;
     }) : Promise.resolve(null);
     const [rawSnapshotYaml, title, downsampledBase64] = await Promise.all([
-      this.traced(
-        "snapshot_for_ai",
-        "capture accessibility tree",
-        () => this.captureSnapshotInternal(opts?.signal)
-      ),
-      this.getPage().then((p2) => p2.title()),
+      this.captureTreeYaml(opts?.signal),
+      this.raceAgainstSignal(
+        "snapshot:title",
+        opts?.signal,
+        () => this.withOperationTimeout(
+          this.getPage().then((p2) => p2.title()),
+          TIMEOUTS.GET_TITLE,
+          "snapshot:title"
+        )
+      ).catch(() => ""),
       captureScreenshot
     ]);
     const snapshotYaml = this.filterSnapshot(
@@ -48874,15 +49637,7 @@ ${warning}` : ""}`,
     // tracking pixels
   ];
   async waitForNetworkIdle(timeoutMs = TIMEOUTS.STABILIZE_INTERACTION) {
-    const page = this.page;
-    if (!page || page.isClosed()) return;
-    try {
-      await page.waitForLoadState("networkidle", { timeout: timeoutMs });
-    } catch {
-      this.logger.debug("[DirectPlaywright] waitForNetworkIdle timed out, proceeding", {
-        timeoutMs
-      });
-    }
+    await this.waitForHttpSettle(timeoutMs);
   }
   getPendingNetworkInfo() {
     const pendingRequests = [];
@@ -48903,6 +49658,40 @@ ${warning}` : ""}`,
     });
     return { pendingCount: pendingRequests.length, sampleUrls };
   }
+  /**
+   * Stream-aware HTTP-settle wait (replaces Playwright `networkidle` in
+   * stabilization). Resolves when no non-stream HTTP request is awaiting
+   * response headers, or after `maxWaitMs`. SSE/WebSocket connections never
+   * block it — their response headers land immediately so they're non-pending,
+   * and `eventsource`/`websocket` resource types are excluded outright. A
+   * request stuck pending past `HTTP_SETTLE_MAX_AGE` is aged out. Best-effort:
+   * the cap always wins.
+   */
+  async waitForHttpSettle(maxWaitMs) {
+    const page = this.page;
+    if (!page || page.isClosed()) return;
+    const deadline = Date.now() + maxWaitMs;
+    const POLL_MS = 50;
+    while (this.countUnsettledRequests() > 0) {
+      if (Date.now() >= deadline) {
+        const pending = this.getPendingNetworkInfo();
+        this.logger.debug("[DirectPlaywright] HTTP-settle deadline reached, proceeding", {
+          maxWaitMs,
+          pendingCount: pending.pendingCount,
+          sampleUrls: pending.sampleUrls
+        });
+        return;
+      }
+      await new Promise((r2) => setTimeout(r2, POLL_MS));
+    }
+  }
+  /** Pending non-stream HTTP requests younger than the age guard. 0 ⇒ settled. */
+  countUnsettledRequests() {
+    return countUnsettledRequests(this._capturedNetworkRequests.values(), Date.now(), {
+      noisePatterns: _PlaywrightClient.NOISE_URL_PATTERNS,
+      maxAgeMs: TIMEOUTS.HTTP_SETTLE_MAX_AGE
+    });
+  }
   async networkRequests(_opts) {
     if (this._capturedNetworkRequests.size === 0) {
       return this.formatMCPResponse("No network requests captured");
@@ -50127,17 +50916,30 @@ ${warning}` : ""}`,
    * - Link URLs, heading levels, cursor styles
    * - Same role vocabulary (generic, paragraph, etc.)
    */
+  /**
+   * Full capture = raw substrate (cheap) + augmentation (expensive). Legacy
+   * path (flag off) and any internal caller that wants the complete substrate.
+   * Returns the previous YAML on abort (unchanged behavior).
+   */
   async captureSnapshotInternal(signal) {
     await this.traceGroup("Canary Internal: Capture Snapshot");
     try {
-      return await this._captureSnapshotInternalBody(signal);
+      const previousYaml = this.lastSnapshotYaml;
+      const rawYaml = await this.captureRawSubstrate(signal);
+      if (signal?.aborted || !rawYaml) return previousYaml;
+      return await this.augmentSubstrate(rawYaml, signal);
     } finally {
       await this.traceGroupEnd();
     }
   }
-  async _captureSnapshotInternalBody(signal) {
+  /**
+   * CHEAP tier: read toasts, run the pre-snapshot DOM enrichers, and take the
+   * `ariaSnapshot`. Returns the raw (un-augmented) substrate YAML — the
+   * ground-truth representation used for freshness comparison — or '' if the
+   * capture was aborted mid-way.
+   */
+  async captureRawSubstrate(signal) {
     const page = await this.getPage();
-    const previousYaml = this.lastSnapshotYaml;
     let capturedToasts = [];
     try {
       capturedToasts = await this.raceAgainstSignal(
@@ -50152,7 +50954,7 @@ ${warning}` : ""}`,
       );
     } catch {
     }
-    if (signal?.aborted) return previousYaml;
+    if (signal?.aborted) return "";
     if (capturedToasts.length > 0) {
       for (const t2 of capturedToasts) {
         t2.snapshotsRemaining = TOAST_SNAPSHOT_TTL;
@@ -50161,14 +50963,14 @@ ${warning}` : ""}`,
       for (const t2 of capturedToasts) {
         existingByText.set(t2.text, t2);
       }
-      if (signal?.aborted) return previousYaml;
+      if (signal?.aborted) return "";
       this._lastCapturedToasts = Array.from(existingByText.values());
       this.logger.debug("[DirectPlaywright] Captured ephemeral toasts", {
         count: capturedToasts.length,
         texts: capturedToasts.map((t2) => t2.text)
       });
     }
-    if (signal?.aborted) return previousYaml;
+    if (signal?.aborted) return "";
     await this.traced(
       "enrichment",
       "DOM enrichment (SVG, hidden, modals)",
@@ -50182,43 +50984,56 @@ ${warning}` : ""}`,
         ]).then(() => void 0)
       )
     );
-    if (signal?.aborted) return previousYaml;
-    let snapshot;
-    const maxRetries = 3;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      if (signal?.aborted) return previousYaml;
-      try {
-        snapshot = await this.raceAgainstSignal(
-          "snapshot:aria",
-          signal,
-          () => page.ariaSnapshot({ mode: "ai" })
-        );
-        break;
-      } catch (err) {
-        if (signal?.aborted) return previousYaml;
-        if (attempt < maxRetries) {
-          this.logger.debug("[DirectPlaywright] Snapshot attempt failed, retrying", {
-            attempt,
-            maxRetries,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          await this.raceAgainstSignal(
-            "snapshot:retry-backoff",
+    if (signal?.aborted) return "";
+    const snapshot = await this.traced("snapshot_for_ai", "capture accessibility tree", async () => {
+      let result;
+      const maxRetries = 3;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        if (signal?.aborted) return void 0;
+        try {
+          result = await this.raceAgainstSignal(
+            "snapshot:aria",
             signal,
-            () => new Promise((resolve) => setTimeout(resolve, 200 * attempt))
+            () => page.ariaSnapshot({ mode: "ai" })
           );
-        } else {
-          this.logger.warn(
-            "[DirectPlaywright] All snapshot attempts failed, using empty fallback",
-            {
-              attempts: maxRetries,
+          break;
+        } catch (err) {
+          if (signal?.aborted) return void 0;
+          if (attempt < maxRetries) {
+            this.logger.debug("[DirectPlaywright] Snapshot attempt failed, retrying", {
+              attempt,
+              maxRetries,
               error: err instanceof Error ? err.message : String(err)
-            }
-          );
+            });
+            await this.raceAgainstSignal(
+              "snapshot:retry-backoff",
+              signal,
+              () => new Promise((resolve) => setTimeout(resolve, 200 * attempt))
+            );
+          } else {
+            this.logger.warn(
+              "[DirectPlaywright] All snapshot attempts failed, using empty fallback",
+              {
+                attempts: maxRetries,
+                error: err instanceof Error ? err.message : String(err)
+              }
+            );
+          }
         }
       }
-    }
-    const rawYaml = snapshot || "- page: (empty)";
+      return result;
+    });
+    if (signal?.aborted) return "";
+    return snapshot || "- page: (empty)";
+  }
+  /**
+   * EXPENSIVE tier: augment a raw substrate into the full substrate (per-ref
+   * DOM-derived hints, v2 attrs, frame selectors). Publishes `lastSnapshotYaml`.
+   * Returns the previous YAML on abort.
+   */
+  async augmentSubstrate(rawYaml, signal) {
+    const page = await this.getPage();
+    const previousYaml = this.lastSnapshotYaml;
     if (signal?.aborted) return previousYaml;
     const augmentedYaml = await this.traced("augmentation", "YAML augmentation (labels, grids, forms, selects)", () => this.raceAgainstSignal("snapshot:augmentation", signal, async () => {
       const elements = parseSnapshot(rawYaml);
@@ -50384,6 +51199,27 @@ ${warning}` : ""}`,
     if (Date.now() - this.lastSnapshotTimestamp > maxAgeMs) return null;
     return this.lastSnapshotYaml;
   }
+  /**
+   * Return the warm (augmented) snapshot YAML if its raw substrate still matches
+   * the live page, else null — verified with a cheap raw capture, never
+   * augmenting. Used by the executor to reuse the warm snapshot as a diff
+   * baseline. Returns null when live-snapshot is disabled (caller falls back to
+   * a fresh capture).
+   */
+  async getReusableSnapshotYaml() {
+    if (!this.liveSnapshotEnabled) return null;
+    const reusable = await this.liveSnapshot.getReusable();
+    return reusable ? mintedYaml(reusable) : null;
+  }
+  /**
+   * Fire-and-forget background *preparation* of the next snapshot. Waits for the
+   * DOM to settle, then re-captures and re-augments on change so the next
+   * request hits the reuse path. No-op when live-snapshot is disabled.
+   */
+  warmSnapshot(opts) {
+    if (!this.liveSnapshotEnabled) return;
+    this.liveSnapshot.warm({ ...opts, rawOnMiss: this.liveSnapshotRawOnMiss });
+  }
   // ================ CDP SCREENCAST ================
   async startScreencast(onFrame, options) {
     if (!this.page) {
@@ -50499,22 +51335,51 @@ ${warning}` : ""}`,
    *   - 'interaction': Brief DOM delay + network idle (after click/submit)
    *   - 'dom-only': Just DOM/animation settling (before snapshot, after hover)
    */
-  async stabilize(type) {
+  async stabilize(type, signal) {
     const page = this.page;
     if (!page || page.isClosed()) return;
     try {
       switch (type) {
         case "navigation":
-          await page.waitForLoadState("networkidle", { timeout: TIMEOUTS.STABILIZE_NAV }).catch(() => {
+          await this.raceAgainstSignal(
+            "stabilize:dom",
+            signal,
+            () => this.waitDomQuiet(this.stabilizeDomMs, TIMEOUTS.STABILIZE_NAV)
+          ).catch(() => {
+          });
+          await this.raceAgainstSignal(
+            "stabilize:http",
+            signal,
+            () => this.waitForHttpSettle(TIMEOUTS.STABILIZE_NAV)
+          ).catch(() => {
           });
           break;
         case "interaction":
-          await page.waitForTimeout(TIMEOUTS.STABILIZE_DOM);
-          await page.waitForLoadState("networkidle", { timeout: TIMEOUTS.STABILIZE_INTERACTION }).catch(() => {
+          await this.raceAgainstSignal(
+            "stabilize:dom-delay",
+            signal,
+            () => page.waitForTimeout(this.stabilizeDomMs)
+          ).catch(() => {
+          });
+          await this.raceAgainstSignal(
+            "stabilize:http",
+            signal,
+            () => this.waitForHttpSettle(TIMEOUTS.STABILIZE_INTERACTION)
+          ).catch(() => {
           });
           break;
         case "dom-only":
-          await page.waitForTimeout(TIMEOUTS.STABILIZE_DOM);
+          if (this.liveSnapshotEnabled) {
+            await this.raceAgainstSignal(
+              "stabilize:dom",
+              signal,
+              () => this.waitDomQuiet(this.stabilizeDomMs, TIMEOUTS.STABILIZE_INTERACTION)
+            ).catch(() => {
+            });
+          } else {
+            await page.waitForTimeout(this.stabilizeDomMs).catch(() => {
+            });
+          }
           break;
       }
     } catch (err) {
@@ -50740,7 +51605,7 @@ Legacy two-step (only if you need to change the action between calls): browser_h
       });
     });
     page.on("close", () => {
-      if (this.pageClosedIntentionally || this.contextClosedIntentionally || this.disconnectInProgress) {
+      if (this.pageClosedIntentionally || this.contextClosedIntentionally || this.disconnectInProgress || this.forcedTeardownInProgress) {
         this.logger.debug("[DirectPlaywright] Page closed intentionally");
         return;
       }
@@ -50783,7 +51648,9 @@ Legacy two-step (only if you need to change the action between calls): browser_h
         method: request2.method(),
         url: request2.url(),
         status: "pending",
-        statusText: ""
+        statusText: "",
+        resourceType: request2.resourceType(),
+        startedAt: Date.now()
       });
     });
     page.on("response", (response) => {
@@ -50929,6 +51796,7 @@ Legacy two-step (only if you need to change the action between calls): browser_h
     this._pendingDialogs = [];
     this.setPendingArm(null, "createPageWithListeners");
     this.lastSnapshotYaml = "";
+    this.liveSnapshot.reset();
     this.highlightStylesInjected = false;
     this.cursorOverlay.resetInjectionState();
     this.setupPageEventListeners(page);
@@ -50949,6 +51817,11 @@ Legacy two-step (only if you need to change the action between calls): browser_h
         error: err instanceof Error ? err.message : String(err)
       });
     });
+    void context.addInitScript(DOM_REVISION_SCRIPT).catch((err) => {
+      this.logger.warn("[DirectPlaywright] Failed to install dom-revision init script", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
     void context.grantPermissions(["microphone", "camera"]).catch((err) => {
       this.logger.warn("[DirectPlaywright] Failed to grant media permissions", {
         error: err instanceof Error ? err.message : String(err)
@@ -51977,4 +52850,4 @@ playwright-extra/dist/index.esm.js:
    * @license MIT
    *)
 */
-//# sourceMappingURL=chunk-4PNOV7OV.js.map
+//# sourceMappingURL=chunk-QQVWGWPI.js.map