@runcofactor/cli 0.16.0 → 0.18.0

package/dist/{chunk-AI3Y3AZH.js → chunk-7OO3RJYR.js}

@@ -3877,13 +3877,13 @@ var require_gifutil = __commonJS({
       }
       _quantize(imageOrImages, "WuQuant", maxColorIndexes, significantBits, dither);
     };
-    exports.read = function(source, decoder) {
-      decoder = decoder || defaultCodec;
+    exports.read = function(source, decoder2) {
+      decoder2 = decoder2 || defaultCodec;
       if (Buffer.isBuffer(source)) {
-        return decoder.decodeGif(source);
+        return decoder2.decodeGif(source);
       }
       return _readBinary(source).then((buffer) => {
-        return decoder.decodeGif(buffer);
+        return decoder2.decodeGif(buffer);
       });
     };
     exports.shareAsJimp = function(jimp, bitmapImageToShare) {
@@ -3895,13 +3895,13 @@ var require_gifutil = __commonJS({
       jimpImage.bitmap.data = bitmapImageToShare.bitmap.data;
       return jimpImage;
     };
-    exports.write = function(path6, frames, spec, encoder) {
-      encoder = encoder || defaultCodec;
+    exports.write = function(path6, frames, spec, encoder2) {
+      encoder2 = encoder2 || defaultCodec;
       const matches = path6.match(/\.[a-zA-Z]+$/);
       if (matches !== null && INVALID_SUFFIXES.includes(matches[0].toLowerCase())) {
         throw new Error(`GIF '${path6}' has an unexpected suffix`);
       }
-      return encoder.encodeGif(frames, spec).then((gif2) => {
+      return encoder2.encodeGif(frames, spec).then((gif2) => {
         return _writeBinary(path6, gif2.buffer).then(() => {
           return gif2;
         });
@@ -5449,8 +5449,8 @@ var require_encoder = __commonJS({
     }
     function encode3(imgData, qu) {
       if (typeof qu === "undefined") qu = 50;
-      var encoder = new JPEGEncoder(qu);
-      var data2 = encoder.encode(imgData, qu);
+      var encoder2 = new JPEGEncoder(qu);
+      var data2 = encoder2.encode(imgData, qu);
       return {
         data: data2,
         width: imgData.width,
@@ -6489,22 +6489,22 @@ var require_decoder = __commonJS({
       };
       var opts = { ...defaultOpts, ...userOpts };
       var arr = new Uint8Array(jpegData);
-      var decoder = new JpegImage();
-      decoder.opts = opts;
+      var decoder2 = new JpegImage();
+      decoder2.opts = opts;
       JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);
-      decoder.parse(arr);
+      decoder2.parse(arr);
       var channels = opts.formatAsRGBA ? 4 : 3;
-      var bytesNeeded = decoder.width * decoder.height * channels;
+      var bytesNeeded = decoder2.width * decoder2.height * channels;
       try {
         JpegImage.requestMemoryAllocation(bytesNeeded);
         var image2 = {
-          width: decoder.width,
-          height: decoder.height,
-          exifBuffer: decoder.exifBuffer,
+          width: decoder2.width,
+          height: decoder2.height,
+          exifBuffer: decoder2.exifBuffer,
           data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer.alloc(bytesNeeded)
         };
-        if (decoder.comments.length > 0) {
-          image2["comments"] = decoder.comments;
+        if (decoder2.comments.length > 0) {
+          image2["comments"] = decoder2.comments;
         }
       } catch (err) {
         if (err instanceof RangeError) {
@@ -6517,7 +6517,7 @@ var require_decoder = __commonJS({
         }
         throw err;
       }
-      decoder.copyToImageData(image2, opts.formatAsRGBA);
+      decoder2.copyToImageData(image2, opts.formatAsRGBA);
       return image2;
     }
   }
@@ -24616,14 +24616,14 @@ var require_merge_deep = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/puppeteer-extra-plugin@3.2.3+e57d6a82292734a1/node_modules/puppeteer-extra-plugin/dist/index.esm.js
+// ../../node_modules/.bun/puppeteer-extra-plugin@3.2.3+174067defc7674c7/node_modules/puppeteer-extra-plugin/dist/index.esm.js
 var index_esm_exports = {};
 __export(index_esm_exports, {
   PuppeteerExtraPlugin: () => PuppeteerExtraPlugin
 });
 var import_debug2, merge, PuppeteerExtraPlugin;
 var init_index_esm = __esm({
-  "../../node_modules/.bun/puppeteer-extra-plugin@3.2.3+e57d6a82292734a1/node_modules/puppeteer-extra-plugin/dist/index.esm.js"() {
+  "../../node_modules/.bun/puppeteer-extra-plugin@3.2.3+174067defc7674c7/node_modules/puppeteer-extra-plugin/dist/index.esm.js"() {
     "use strict";
     import_debug2 = __toESM(require_src());
     merge = require_merge_deep();
@@ -25086,9 +25086,9 @@ var init_index_esm = __esm({
   }
 });
 
-// ../../node_modules/.bun/puppeteer-extra-plugin-stealth@2.11.2+e57d6a82292734a1/node_modules/puppeteer-extra-plugin-stealth/index.js
+// ../../node_modules/.bun/puppeteer-extra-plugin-stealth@2.11.2+174067defc7674c7/node_modules/puppeteer-extra-plugin-stealth/index.js
 var require_puppeteer_extra_plugin_stealth = __commonJS({
-  "../../node_modules/.bun/puppeteer-extra-plugin-stealth@2.11.2+e57d6a82292734a1/node_modules/puppeteer-extra-plugin-stealth/index.js"(exports, module) {
+  "../../node_modules/.bun/puppeteer-extra-plugin-stealth@2.11.2+174067defc7674c7/node_modules/puppeteer-extra-plugin-stealth/index.js"(exports, module) {
     "use strict";
     var { PuppeteerExtraPlugin: PuppeteerExtraPlugin2 } = (init_index_esm(), __toCommonJS(index_esm_exports));
     var StealthPlugin2 = class extends PuppeteerExtraPlugin2 {
@@ -40257,11 +40257,17 @@ import * as path2 from "path";
 import * as path3 from "path";
 import * as fs22 from "fs/promises";
 import * as crypto3 from "crypto";
+import { cpus } from "os";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
 import {
   chromium as playwrightChromium
 } from "playwright";
 
-// ../../node_modules/.bun/playwright-extra@4.3.6+8de3b499c6b19053/node_modules/playwright-extra/dist/index.esm.js
+// ../../node_modules/.bun/playwright-extra@4.3.6+0a2747ebf12ccdf9/node_modules/playwright-extra/dist/index.esm.js
 var import_debug = __toESM(require_src());
 var Loader = class {
   constructor(moduleName, packageNames) {
@@ -41654,6 +41660,16 @@ var TIMEOUTS = {
   GET_TITLE: 2e4,
   GET_LINKS: 2e4,
   SNAPSHOT: 3e4,
+  // Driver-side hard cap for a single `page.ariaSnapshot()` call. ariaSnapshot
+  // has NO Playwright timeout and ignores AbortSignal: on a jammed renderer
+  // (blocked main thread / native dialog) the op parks for minutes, and the
+  // per-tool timeout's abort can't cancel it — the orphan kept running until
+  // the 1800s job-stall watchdog tore down the whole job (prod, June 2026).
+  // This cap makes the *driver* give up and fall back to an empty snapshot so
+  // the agent keeps moving; the wedged page is then reaped by step-level
+  // force-recovery. Kept below POST_ACTION_SNAPSHOT (15s) and SNAPSHOT (30s) so
+  // the inner cap wins; a healthy ariaSnapshot returns in <1s.
+  ARIA_SNAPSHOT_CAP: 12e3,
   CLICK: 1e4,
   TYPE: 1e4,
   FILL_FORM: 2e4,
@@ -42004,6 +42020,9 @@ function extractAndStripV2Fields(attributes) {
           out.visibility = value;
         }
         break;
+      case "~dialog-inert":
+        if (value === "true") out.dialogInert = true;
+        break;
       case "~bbox": {
         const parts = value.split(":").map((s2) => parseFloat(s2));
         if (parts.length === 4 && parts.every((n2) => Number.isFinite(n2))) {
@@ -42348,6 +42367,192 @@ function appendAttrToLine(line, segment) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var ICON_FAMILY_PREFIXES = [
+  // FontAwesome family + style tokens
+  "fa-solid-",
+  "fa-regular-",
+  "fa-light-",
+  "fa-thin-",
+  "fa-duotone-",
+  "fa-brands-",
+  "fa-sharp-",
+  "fa-",
+  "fas-",
+  "far-",
+  "fal-",
+  "fad-",
+  "fab-",
+  // Telerik / Kendo
+  "k-svg-i-",
+  "k-i-",
+  // Bootstrap Icons, Material Design Icons, Glyphicons, Ionicons
+  "bi-",
+  "mdi-",
+  "glyphicon-",
+  "ion-",
+  "material-icons-",
+  // Generic convention
+  "icon-"
+];
+var ICON_NOISE_TOKENS = /* @__PURE__ */ new Set([
+  "fa",
+  "fa-solid",
+  "fa-regular",
+  "fa-light",
+  "fa-thin",
+  "fa-duotone",
+  "fa-brands",
+  "fa-sharp",
+  "fas",
+  "far",
+  "fal",
+  "fad",
+  "fab",
+  "fa-lg",
+  "fa-sm",
+  "fa-xs",
+  "fa-xl",
+  "fa-fw",
+  "fa-spin",
+  "fa-pulse",
+  "fa-border",
+  "fa-pull-left",
+  "fa-pull-right",
+  "k-icon",
+  "k-svg-icon",
+  "k-button-icon"
+]);
+var ICON_NAME_MAP = {
+  // export / data movement
+  "file-export": "Export",
+  "file-arrow-down": "Export",
+  "arrow-up-from-bracket": "Export",
+  export: "Export",
+  download: "Download",
+  "file-download": "Download",
+  "cloud-arrow-down": "Download",
+  "arrow-down-to-line": "Download",
+  upload: "Upload",
+  "file-upload": "Upload",
+  "cloud-arrow-up": "Upload",
+  "file-import": "Import",
+  "file-arrow-up": "Import",
+  import: "Import",
+  // filtering / search / columns
+  filter: "Filter",
+  "filter-circle-xmark": "Clear filter",
+  funnel: "Filter",
+  sliders: "Filter",
+  "magnifying-glass": "Search",
+  search: "Search",
+  "table-columns": "Columns",
+  columns: "Columns",
+  "table-cells": "Columns",
+  table: "Columns",
+  // settings
+  gear: "Settings",
+  gears: "Settings",
+  cog: "Settings",
+  cogs: "Settings",
+  wrench: "Settings",
+  sliders2: "Settings",
+  // CRUD
+  plus: "Add",
+  "plus-circle": "Add",
+  "circle-plus": "Add",
+  add: "Add",
+  pen: "Edit",
+  pencil: "Edit",
+  "pen-to-square": "Edit",
+  "pencil-alt": "Edit",
+  edit: "Edit",
+  trash: "Delete",
+  "trash-can": "Delete",
+  "trash-alt": "Delete",
+  delete: "Delete",
+  "floppy-disk": "Save",
+  save: "Save",
+  copy: "Copy",
+  clone: "Copy",
+  // navigation / disclosure
+  xmark: "Close",
+  times: "Close",
+  x: "Close",
+  "circle-xmark": "Close",
+  close: "Close",
+  "chevron-down": "Expand",
+  "chevron-up": "Collapse",
+  "chevron-left": "Previous",
+  "chevron-right": "Next",
+  "angle-down": "Expand",
+  "angle-up": "Collapse",
+  "angle-left": "Previous",
+  "angle-right": "Next",
+  "caret-down": "Expand",
+  "caret-up": "Collapse",
+  "caret-left": "Previous",
+  "caret-right": "Next",
+  "arrow-left": "Back",
+  "arrow-right": "Forward",
+  // misc actions
+  ellipsis: "More",
+  "ellipsis-vertical": "More",
+  "ellipsis-v": "More",
+  "ellipsis-h": "More",
+  bars: "Menu",
+  bell: "Notifications",
+  "circle-info": "Info",
+  "info-circle": "Info",
+  info: "Info",
+  "circle-question": "Help",
+  "question-circle": "Help",
+  question: "Help",
+  check: "Confirm",
+  "circle-check": "Confirm",
+  eye: "Show",
+  "eye-slash": "Hide",
+  "arrows-rotate": "Refresh",
+  "arrow-rotate-right": "Refresh",
+  rotate: "Refresh",
+  refresh: "Refresh",
+  sync: "Refresh",
+  print: "Print",
+  printer: "Print",
+  share: "Share",
+  "share-nodes": "Share",
+  calendar: "Calendar",
+  "calendar-days": "Calendar",
+  star: "Favorite",
+  print2: "Print"
+};
+function stripIconFamilyPrefix(raw) {
+  let name = raw.trim().toLowerCase();
+  if (!name) return void 0;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of ICON_FAMILY_PREFIXES) {
+      if (name.startsWith(prefix) && name.length > prefix.length) {
+        name = name.slice(prefix.length);
+        changed = true;
+        break;
+      }
+    }
+  }
+  if (!name || ICON_NOISE_TOKENS.has(name) || ICON_NOISE_TOKENS.has(raw.trim().toLowerCase())) {
+    return void 0;
+  }
+  return name;
+}
+function resolveIconClassName(raw) {
+  const name = stripIconFamilyPrefix(raw);
+  if (!name) return void 0;
+  const mapped = ICON_NAME_MAP[name];
+  if (mapped) return mapped;
+  const base = name.replace(/-\d+$/, "");
+  if (base !== name && ICON_NAME_MAP[base]) return ICON_NAME_MAP[base];
+  return name.split("-").filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
 async function resolveRefs(scope, refs, fn) {
   if (refs.length === 0) return {};
   const handles = await Promise.all(
@@ -42438,20 +42643,31 @@ async function resolveRefsWithArgs(scope, items, globals, fn) {
     );
   }
 }
+function isFrameworkMarkerClass(cls) {
+  if (cls === "telerik-blazor") return true;
+  return /^(k|mat|mdc|ng|chakra|ant|el|v|q)-/.test(cls) || /^mui[A-Z-]/.test(cls);
+}
 function extractSemanticHint(className) {
   if (!className) return void 0;
   const classes = className.split(/\s+/).filter(Boolean);
+  const isNoise = (cls) => {
+    if (/^(css|sc|emotion|styled|svelte)-/.test(cls)) return true;
+    if (/^(clickable-element|bubble-element|bubble-r-container|bubble-r-vertical-center)/.test(cls)) return true;
+    if (/^_[a-zA-Z0-9]{4,}$/.test(cls)) return true;
+    if (/^(p|m|w|h|gap|text|bg|border|rounded|shadow|opacity|z|flex|grid|block|inline|hidden|relative|absolute|fixed|sticky|overflow|cursor|transition|ring|outline|sr|not|group|peer|dark|hover|focus|active|disabled|data|aria)-/.test(cls)) return true;
+    if (/^(items|justify|self|place|space|divide|whitespace|break|font|leading|tracking|decoration|underline|overline|line|list|placeholder|align|content|object|max|min|inset|top|right|bottom|left|order|auto|grow|shrink|basis|table|caption|scale|rotate|translate|skew|origin|select|snap|scroll|touch|resize|appearance|columns|aspect|accent|caret|fill|stroke|will|animate|delay|duration|ease)-./.test(cls)) return true;
+    if (/^(flex|grid|block|inline|hidden|table|contents)$/.test(cls)) return true;
+    if (isFrameworkMarkerClass(cls)) return true;
+    return false;
+  };
+  const KEYWORD_RE = /delete|remove|trash|edit|save|close|submit|cancel|add|create|copy|refresh|back|forward|next|prev|menu|nav|icon|btn|button|action|toggle|collapse|expand|upload|download|export|import|filter|search|settings|help|info|warning|error/i;
   for (const cls of classes) {
-    if (/^(css|sc|emotion|styled|svelte)-/.test(cls)) continue;
-    if (/^(clickable-element|bubble-element|bubble-r-container|bubble-r-vertical-center)/.test(cls)) continue;
-    if (/^_[a-zA-Z0-9]{4,}$/.test(cls)) continue;
-    if (/^(p|m|w|h|gap|text|bg|border|rounded|shadow|opacity|z|flex|grid|block|inline|hidden|relative|absolute|fixed|sticky|overflow|cursor|transition|ring|outline|sr|not|group|peer|dark|hover|focus|active|disabled|data|aria)-/.test(cls)) continue;
-    if (/^(items|justify|self|place|space|divide|whitespace|break|font|leading|tracking|decoration|underline|overline|line|list|placeholder|align|content|object|max|min|inset|top|right|bottom|left|order|auto|grow|shrink|basis|table|caption|scale|rotate|translate|skew|origin|select|snap|scroll|touch|resize|appearance|columns|aspect|accent|caret|fill|stroke|will|animate|delay|duration|ease)-./.test(cls)) continue;
-    if (/^(flex|grid|block|inline|hidden|table|contents)$/.test(cls)) continue;
-    if (/delete|remove|trash|edit|save|close|submit|cancel|add|create|copy|refresh|back|forward|next|prev|menu|nav|icon|btn|button|action|toggle|collapse|expand|upload|download|settings|help|info|warning|error/i.test(cls)) {
-      return cls;
-    }
-    if (/^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)+$/.test(cls) && cls.length >= 6) {
+    if (isNoise(cls)) continue;
+    if (KEYWORD_RE.test(cls)) return cls;
+  }
+  for (const cls of classes) {
+    if (isNoise(cls)) continue;
+    if (/^[a-z][a-z0-9]*((-{1,2}|__)[a-z][a-z0-9]*)+$/.test(cls) && cls.length >= 6) {
       return cls;
     }
   }
@@ -42547,6 +42763,9 @@ function planChecks(elements, opts) {
       if (opts.v2 && el.role === "generic" && hasInteractive(el)) {
         addCheck(el.ref, "modalV2");
       }
+      if (el.role === "dialog" || el.role === "alertdialog") {
+        addCheck(el.ref, "dialogModality");
+      }
       if ((el.role === "button" || el.role === "link") && (!el.text || hasOnlyPrivateUseGlyphs(el.text))) {
         addCheck(el.ref, "iconButton");
       }
@@ -42789,6 +43008,46 @@ function pageSideFn(el, _ref, args, G) {
       }
     }
   }
+  if (checks.has("dialogModality")) {
+    out.dialogModality = { inert: false };
+    try {
+      const isVisibleStyle = (n2) => {
+        const he = n2;
+        if (he.offsetWidth === 0 && he.offsetHeight === 0 && he.getClientRects().length === 0) {
+          return false;
+        }
+        const style = window.getComputedStyle(n2);
+        if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
+          return false;
+        }
+        if (parseFloat(style.opacity || "1") === 0) return false;
+        return true;
+      };
+      let visible = true;
+      let cur = el;
+      for (let i2 = 0; i2 < 25 && cur; i2++) {
+        if (!isVisibleStyle(cur)) {
+          visible = false;
+          break;
+        }
+        cur = cur.parentElement;
+      }
+      let onScreen = true;
+      if (visible) {
+        const rect = el.getBoundingClientRect();
+        const vw = window.innerWidth || document.documentElement.clientWidth || 0;
+        const vh = window.innerHeight || document.documentElement.clientHeight || 0;
+        if (rect.width === 0 || rect.height === 0) {
+          onScreen = false;
+        } else if (rect.right <= 0 || rect.bottom <= 0 || rect.left >= vw || rect.top >= vh) {
+          onScreen = false;
+        }
+      }
+      out.dialogModality = { inert: !(visible && onScreen) };
+    } catch {
+      out.dialogModality = null;
+    }
+  }
   const extractSvgHint = (root) => {
     const svg = root.querySelector("svg");
     if (!svg) return {};
@@ -42815,6 +43074,38 @@ function pageSideFn(el, _ref, args, G) {
     if (m) lucideIconClass = m[0].toLowerCase();
     return { svgHint, lucideIconClass };
   };
+  const extractIconClass = (root) => {
+    const FA_STYLE = /^fa-(solid|regular|light|thin|duotone|brands|sharp)$/;
+    const FA_SIZE = /^fa-(2?xs|sm|lg|xl|2xl|fw|spin|pulse|border|inverse|stack(-[12]x)?|pull-left|pull-right|beat|fade|flip|shake|bounce|spin-pulse|rotate-[0-9a-z]+|flip-[a-z]+)$/;
+    const classOf = (node) => typeof node.className === "string" ? node.className : node.getAttribute("class") || "";
+    const pick = (raw, allowGeneric) => {
+      const tokens = raw.split(/\s+/).filter(Boolean);
+      for (const t2 of tokens) {
+        if (/^fa-/.test(t2) && t2 !== "fa" && !FA_STYLE.test(t2) && !FA_SIZE.test(t2)) return t2;
+      }
+      for (const t2 of tokens) {
+        if (/^k-svg-i-/.test(t2) || /^k-i-/.test(t2)) return t2;
+      }
+      if (allowGeneric) {
+        for (const t2 of tokens) if (/^icon-[a-z]/.test(t2)) return t2;
+      }
+      return void 0;
+    };
+    const rootHit = pick(classOf(root), false);
+    if (rootHit) return rootHit;
+    let kids = [];
+    try {
+      kids = Array.from(root.querySelectorAll("i, svg, em, span"));
+    } catch {
+      kids = [];
+    }
+    for (const node of kids) {
+      const tag = node.tagName;
+      const hit = pick(classOf(node), tag === "I" || tag === "SVG" || tag === "EM");
+      if (hit) return hit;
+    }
+    return void 0;
+  };
   if (checks.has("iconButton")) {
     try {
       const ariaLabel = el.getAttribute("aria-label") || void 0;
@@ -42872,6 +43163,7 @@ function pageSideFn(el, _ref, args, G) {
           }
         }
       }
+      const iconClass = extractIconClass(el);
       out.iconButton = {
         ariaLabel,
         title,
@@ -42889,7 +43181,8 @@ function pageSideFn(el, _ref, args, G) {
         reactComponentName,
         id: el.id || void 0,
         className: typeof el.className === "string" ? el.className : void 0,
-        lucideIconClass
+        lucideIconClass,
+        iconClass
       };
     } catch {
       out.iconButton = null;
@@ -42902,9 +43195,19 @@ function pageSideFn(el, _ref, args, G) {
       const id = el.id || void 0;
       const className = typeof el.className === "string" ? el.className : void 0;
       const { svgHint, lucideIconClass } = extractSvgHint(el);
+      const iconClass = extractIconClass(el);
       const rawInnerText = el instanceof HTMLElement ? el.innerText : void 0;
       const innerText = rawInnerText?.replace(/\n+/g, " ").trim().slice(0, 80) || void 0;
-      out.genericClickable = { title, ariaLabel, svgHint, id, className, innerText, lucideIconClass };
+      out.genericClickable = {
+        title,
+        ariaLabel,
+        svgHint,
+        id,
+        className,
+        innerText,
+        lucideIconClass,
+        iconClass
+      };
     } catch {
       out.genericClickable = null;
     }
@@ -43192,6 +43495,9 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
       if (r2.hclip) {
         lines[i2] = appendAttributeIfMissing(lines[i2], "~hclip", r2.hclip);
       }
+      if (r2.dialogModality?.inert) {
+        lines[i2] = appendAttributeIfMissing(lines[i2], "~dialog-inert", "true");
+      }
       if (r2.gridCellValue) {
         const escaped = r2.gridCellValue.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
         lines[i2] = appendValueTail(lines[i2], escaped);
@@ -43240,7 +43546,7 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
         const linePreLabel = lines[i2];
         const role = linePreLabel.includes("- link") ? "link" : "button";
         const pathnameLabel = role === "link" ? labelFromPathname(h.pathname) : void 0;
-        const hint = h.title || h.ariaLabel || h.svgHint || h.srText || h.imgAlt || pathnameLabel || h.reactComponentName || (h.id || void 0) || extractSemanticHint(h.className);
+        const hint = h.title || h.ariaLabel || h.svgHint || h.srText || h.imgAlt || (h.iconClass ? resolveIconClassName(h.iconClass) : void 0) || pathnameLabel || h.reactComponentName || (h.id || void 0) || extractSemanticHint(h.className);
         if (hint) {
           lines[i2] = injectElementLabel(lines[i2], role, hint);
           tagAugmentedNameSource(i2);
@@ -43254,6 +43560,8 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
         if (h.ariaCurrent) line = appendAttributeIfMissing(line, "aria-current", h.ariaCurrent);
         if (h.lucideIconClass) {
           line = appendAttributeIfMissing(line, "~icon-class", h.lucideIconClass);
+        } else if (h.iconClass) {
+          line = appendAttributeIfMissing(line, "~icon-class", h.iconClass);
         }
         const semanticToken = extractSemanticHint(h.className);
         if (semanticToken) {
@@ -43269,7 +43577,7 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
       }
       if (r2.genericClickable) {
         const h = r2.genericClickable;
-        const hint = h.title || h.ariaLabel || h.innerText || h.svgHint || (h.id || void 0) || extractSemanticHint(h.className);
+        const hint = h.title || h.ariaLabel || h.innerText || h.svgHint || (h.iconClass ? resolveIconClassName(h.iconClass) : void 0) || (h.id || void 0) || extractSemanticHint(h.className);
         if (hint) {
           lines[i2] = injectElementLabel(lines[i2], "generic", hint);
           tagAugmentedNameSource(i2);
@@ -43277,6 +43585,8 @@ async function runPerRefAugmentations(scope, yaml, logger2, opts = {}) {
         let line = lines[i2];
         if (h.lucideIconClass) {
           line = appendAttributeIfMissing(line, "~icon-class", h.lucideIconClass);
+        } else if (h.iconClass) {
+          line = appendAttributeIfMissing(line, "~icon-class", h.iconClass);
         }
         const semanticToken = extractSemanticHint(h.className);
         if (semanticToken) {
@@ -44805,7 +45115,7 @@ var CdpScreencastManager = class {
           return;
         }
         const framerate = Math.round(1e3 / this.legacyOptions.minIntervalMs);
-        const encoder = this.encoderFactory.create({
+        const encoder2 = this.encoderFactory.create({
           framerate,
           onInitSegment: videoCallbacks.onInitSegment,
           onMediaSegment: videoCallbacks.onMediaSegment,
@@ -44816,11 +45126,11 @@ var CdpScreencastManager = class {
             videoCallbacks.onError?.(err);
           }
         });
-        encoder.start();
+        encoder2.start();
         const encoderSub = await this.subscribe(page, {
           onJpeg: (jpeg2) => {
             try {
-              encoder.pushFrame(jpeg2);
+              encoder2.pushFrame(jpeg2);
             } catch (err) {
               getLogger().warn("[CdpScreencast] Failed to push frame to encoder", {
                 error: err instanceof Error ? err.message : String(err)
@@ -44834,7 +45144,7 @@ var CdpScreencastManager = class {
           maxHeight: this.legacyOptions.maxHeight,
           everyNthFrame: this.legacyOptions.everyNthFrame
         });
-        this.legacyEncoder = encoder;
+        this.legacyEncoder = encoder2;
         this.legacyEncoderSubscription = encoderSub;
         this._videoEncodingActive = true;
         getLogger().info("[CdpScreencast] Video encoding enabled", { framerate });
@@ -48168,7 +48478,11 @@ function buildSection(element, depth) {
     if (dismissRef) {
       section.dismissActionRef = dismissRef;
     }
-    if (element.attributes["aria-modal"] === "true") {
+    const inert = element.dialogInert === true || element.visibility === "hidden" || element.visibility === "off-screen";
+    if (inert) {
+      section.isInertDialog = true;
+    }
+    if (element.attributes["aria-modal"] === "true" && !inert) {
       section.isBlockingModal = true;
     }
   }
@@ -48305,7 +48619,7 @@ function sortSectionsByFocus(sections) {
       dialogStack.unshift(focusedDialog.heading);
     }
     for (const dialog of dialogs) {
-      if (!dialog.containsActive) {
+      if (!dialog.containsActive && !dialog.isInertDialog) {
         dialogStack.push(dialog.heading);
       }
     }
@@ -50116,12 +50430,406 @@ async function extractElementMetadata(locator, ref2, _logger3) {
     childImgAlt: domProps.childImgAlt
   };
 }
+init_logger();
+init_logger();
+var READY_ID = 0;
+var HEADER_BYTES = 4;
+var MAX_FRAME_BYTES = 64 * 1024 * 1024;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodeFrame(obj) {
+  const body = encoder.encode(JSON.stringify(obj));
+  const frame = new Uint8Array(HEADER_BYTES + body.length);
+  new DataView(frame.buffer).setUint32(0, body.length, false);
+  frame.set(body, HEADER_BYTES);
+  return frame;
+}
+var FrameDecoder = class {
+  buf = new Uint8Array(0);
+  /** Append a chunk and return every frame that is now complete. */
+  push(chunk) {
+    const next = new Uint8Array(this.buf.length + chunk.length);
+    next.set(this.buf, 0);
+    next.set(chunk, this.buf.length);
+    this.buf = next;
+    const out = [];
+    let offset2 = 0;
+    while (this.buf.length - offset2 >= HEADER_BYTES) {
+      const len = new DataView(this.buf.buffer, this.buf.byteOffset + offset2).getUint32(0, false);
+      if (len > MAX_FRAME_BYTES) {
+        throw new Error(`cpu-offload frame length ${len} exceeds ${MAX_FRAME_BYTES} (corrupt stream)`);
+      }
+      if (this.buf.length - offset2 - HEADER_BYTES < len) break;
+      const start = offset2 + HEADER_BYTES;
+      const body = this.buf.subarray(start, start + len);
+      out.push(JSON.parse(decoder.decode(body)));
+      offset2 = start + len;
+    }
+    if (offset2 > 0) this.buf = this.buf.subarray(offset2);
+    return out;
+  }
+};
+var CpuOffloadTimeoutError = class extends Error {
+  _tag = "CpuOffloadTimeoutError";
+  constructor(task, timeoutMs) {
+    super(`cpu-offload task '${task}' exceeded ${timeoutMs}ms and was terminated`);
+    this.name = "CpuOffloadTimeoutError";
+  }
+};
+var CpuOffloadWorkerError = class extends Error {
+  _tag = "CpuOffloadWorkerError";
+  constructor(message) {
+    super(message);
+    this.name = "CpuOffloadWorkerError";
+  }
+};
+var READY_HANDSHAKE_TIMEOUT_MS = 1e4;
+function resolveCpuOffloadWorkerPath() {
+  const candidates = [
+    new URL("./worker-process.ts", import.meta.url),
+    new URL("./worker-process.js", import.meta.url),
+    new URL("./cpu-offload/worker-process.js", import.meta.url)
+  ].map((u2) => fileURLToPath(u2));
+  const found = candidates.find((p2) => existsSync2(p2));
+  if (found) return found;
+  try {
+    const pkgJson = createRequire(import.meta.url).resolve("@chatsdet/browser-core/package.json");
+    const viaPkg = join2(dirname(pkgJson), "dist", "cpu-offload", "worker-process.js");
+    if (existsSync2(viaPkg)) return viaPkg;
+    candidates.push(viaPkg);
+  } catch {
+  }
+  throw new CpuOffloadWorkerError(`worker entry not found; looked in: ${candidates.join(", ")}`);
+}
+var CpuOffloadPool = class {
+  opts;
+  logger;
+  workers = /* @__PURE__ */ new Set();
+  idle = [];
+  waiters = [];
+  nextId = 1;
+  shuttingDown = false;
+  constructor(options) {
+    this.logger = options.logger ?? consoleLogger;
+    this.opts = {
+      size: Math.max(1, options.size),
+      defaultTimeoutMs: options.defaultTimeoutMs,
+      spawn: options.spawn ?? spawn2,
+      workerPath: options.workerPath ?? resolveCpuOffloadWorkerPath(),
+      execPath: options.execPath ?? process.execPath
+    };
+  }
+  /** Run a registered task. Rejects with a typed error on timeout/crash. */
+  async run(task, payload, runOpts) {
+    if (this.shuttingDown) {
+      throw new CpuOffloadWorkerError("pool is shutting down");
+    }
+    const worker = await this.acquire();
+    const timeoutMs = runOpts?.timeoutMs ?? this.opts.defaultTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const timer = setTimeout(() => this.onTimeout(worker), timeoutMs);
+      worker.current = {
+        id,
+        task,
+        timeoutMs,
+        timer,
+        resolve,
+        reject
+      };
+      const req = { id, task, payload };
+      const stdin = worker.child.stdin;
+      if (!stdin) {
+        this.retireWorker(worker, new CpuOffloadWorkerError("worker has no stdin"));
+        return;
+      }
+      try {
+        stdin.write(encodeFrame(req));
+      } catch (err) {
+        this.retireWorker(
+          worker,
+          new CpuOffloadWorkerError(
+            `failed to write to worker: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+      }
+    });
+  }
+  stats() {
+    return {
+      total: this.workers.size,
+      idle: this.idle.length,
+      busy: this.workers.size - this.idle.length,
+      waiting: this.waiters.length
+    };
+  }
+  async shutdown() {
+    this.shuttingDown = true;
+    for (const waiter of this.waiters) {
+      waiter.reject(new CpuOffloadWorkerError("pool shutting down"));
+    }
+    this.waiters.length = 0;
+    for (const w of this.workers) {
+      w.retired = true;
+      if (w.current) {
+        clearTimeout(w.current.timer);
+        w.current.reject(new CpuOffloadWorkerError("pool shutting down"));
+      }
+      w.child.kill("SIGKILL");
+    }
+    this.workers.clear();
+    this.idle.length = 0;
+  }
+  // ── internals ──────────────────────────────────────────────────────────
+  acquire() {
+    const free = this.idle.pop();
+    if (free) return Promise.resolve(free);
+    if (this.workers.size < this.opts.size) return this.spawnWorker();
+    return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+  }
+  release(worker) {
+    if (worker.retired || this.shuttingDown) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter.resolve(worker);
+    else this.idle.push(worker);
+  }
+  spawnWorker() {
+    const child = this.opts.spawn(this.opts.execPath, [this.opts.workerPath], {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    const worker = { child, decoder: new FrameDecoder(), current: null, retired: false };
+    this.workers.add(worker);
+    return new Promise((resolve, reject) => {
+      let ready = false;
+      let spawnFailed = false;
+      const failSpawn = (err) => {
+        if (ready || spawnFailed) return;
+        spawnFailed = true;
+        clearTimeout(readyTimer);
+        this.workers.delete(worker);
+        worker.child.kill("SIGKILL");
+        reject(err);
+      };
+      const readyTimer = setTimeout(
+        () => failSpawn(new CpuOffloadWorkerError("worker did not become ready in time")),
+        READY_HANDSHAKE_TIMEOUT_MS
+      );
+      child.stdout?.on("data", (chunk) => {
+        let frames;
+        try {
+          frames = worker.decoder.push(chunk);
+        } catch (err) {
+          const wrapped = new CpuOffloadWorkerError(
+            `worker protocol error: ${err instanceof Error ? err.message : String(err)}`
+          );
+          if (ready) this.retireWorker(worker, wrapped);
+          else failSpawn(wrapped);
+          return;
+        }
+        for (const msg of frames) {
+          const resp = msg;
+          if (resp.id === READY_ID) {
+            ready = true;
+            clearTimeout(readyTimer);
+            resolve(worker);
+          } else {
+            this.onResponse(worker, resp);
+          }
+        }
+      });
+      child.on("exit", (code, signal) => {
+        if (!ready) {
+          failSpawn(
+            new CpuOffloadWorkerError(`worker exited before ready (code=${code}, signal=${signal})`)
+          );
+          return;
+        }
+        if (!worker.retired) {
+          this.retireWorker(
+            worker,
+            new CpuOffloadWorkerError(`worker exited unexpectedly (code=${code}, signal=${signal})`)
+          );
+        }
+      });
+      child.on("error", (err) => {
+        if (!ready) {
+          failSpawn(new CpuOffloadWorkerError(`worker spawn failed: ${err.message}`));
+        } else if (!worker.retired) {
+          this.retireWorker(worker, new CpuOffloadWorkerError(`worker error: ${err.message}`));
+        }
+      });
+    });
+  }
+  onResponse(worker, resp) {
+    const call = worker.current;
+    if (!call || call.id !== resp.id) return;
+    clearTimeout(call.timer);
+    worker.current = null;
+    if (resp.ok) call.resolve(resp.result);
+    else call.reject(new CpuOffloadWorkerError(resp.error.message));
+    this.release(worker);
+  }
+  onTimeout(worker) {
+    const call = worker.current;
+    if (!call) return;
+    this.retireWorker(worker, new CpuOffloadTimeoutError(call.task, call.timeoutMs));
+  }
+  /**
+   * Reject any in-flight call, kill the process, drop the worker, and — unless
+   * shutting down — spawn a replacement to keep capacity up and drain waiters.
+   * Idempotent: the SIGKILL's own `exit` event re-enters here as a no-op.
+   */
+  retireWorker(worker, error) {
+    if (worker.retired) return;
+    worker.retired = true;
+    this.workers.delete(worker);
+    const idx = this.idle.indexOf(worker);
+    if (idx >= 0) this.idle.splice(idx, 1);
+    this.logger.warn("[CpuOffloadPool] retiring worker", {
+      pid: worker.child.pid,
+      task: worker.current?.task,
+      reason: error.message,
+      timedOut: error instanceof CpuOffloadTimeoutError
+    });
+    if (worker.current) {
+      clearTimeout(worker.current.timer);
+      worker.current.reject(error);
+      worker.current = null;
+    }
+    worker.child.kill("SIGKILL");
+    if (this.shuttingDown) return;
+    if (this.waiters.length > 0 || this.workers.size < this.opts.size) {
+      this.spawnWorker().then((w) => this.release(w)).catch((err) => {
+        this.logger.error("[CpuOffloadPool] failed to respawn worker; rejecting waiters", {
+          error: err instanceof Error ? err.message : String(err),
+          waiting: this.waiters.length
+        });
+        const drained = this.waiters.splice(0);
+        for (const waiter of drained) {
+          waiter.reject(
+            new CpuOffloadWorkerError(
+              `worker respawn failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+      });
+    }
+  }
+};
+var DEFAULT_CPU_OFFLOAD_TIMEOUT_MS = 15e3;
+var defaultCpuOffloadSize = () => Math.min(8, Math.max(2, Math.floor(cpus().length / 2)));
+var config = { enabled: false };
+var pool = null;
+function configureCpuOffload(next) {
+  config = next;
+  if (typeof next.enabled === "boolean" && next.enabled === false) {
+    void shutdownCpuOffload();
+  }
+}
+function isCpuOffloadEnabled() {
+  const { enabled } = config;
+  return typeof enabled === "function" ? !!enabled() : enabled;
+}
+function getPool() {
+  if (!pool) {
+    pool = new CpuOffloadPool({
+      size: config.size ?? defaultCpuOffloadSize(),
+      defaultTimeoutMs: config.timeoutMs ?? DEFAULT_CPU_OFFLOAD_TIMEOUT_MS,
+      logger: config.logger ?? consoleLogger
+    });
+  }
+  return pool;
+}
+async function shutdownCpuOffload() {
+  const p2 = pool;
+  pool = null;
+  if (p2) await p2.shutdown();
+}
+var TIMEOUT_MARKER = "---\nSEMANTIC SNAPSHOT - formatting timed out\nThe page was too large to format within the time budget. Narrow with browser_snapshot search=\u2026 or scroll to a region.\n---";
+async function formatSnapshotMaybeOffloaded(yaml, options) {
+  if (!isCpuOffloadEnabled()) {
+    return formatSemanticSnapshot(yaml, options);
+  }
+  const logger2 = config.logger ?? consoleLogger;
+  try {
+    const { elementHints, matchedHintIds: _drop, ...rest } = options ?? {};
+    const payload = {
+      yaml,
+      options: rest,
+      ...elementHints ? { elementHints: [...elementHints] } : {}
+    };
+    const result = await getPool().run("format-snapshot", payload);
+    if (options && result.matchedHintIds) {
+      options.matchedHintIds = result.matchedHintIds;
+    }
+    return result.text;
+  } catch (err) {
+    if (err instanceof CpuOffloadTimeoutError) {
+      logger2.warn("[CpuOffload] format-snapshot timed out; returning marker (NOT inlining)", {
+        task: "format-snapshot",
+        error: err.message
+      });
+      return TIMEOUT_MARKER;
+    }
+    logger2.warn("[CpuOffload] format-snapshot offload failed; running inline", {
+      task: "format-snapshot",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return formatSemanticSnapshot(yaml, options);
+  }
+}
 var ToolAbortedError = class extends Error {
   constructor(stage) {
     super(`Browser action aborted at stage: ${stage}`);
     this.name = "ToolAbortedError";
   }
 };
+function labelForContext(context) {
+  return context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+}
+function elementDescription(context) {
+  const role = context.role ? ` role=${context.role}` : "";
+  const type = context.inputType ? ` type=${context.inputType}` : "";
+  return `${context.tagName}${type}${role}`;
+}
+function formatFillTargetNotEditableMessage(context) {
+  if (context.state === "not-fillable") {
+    return `Cannot fill target ${labelForContext(context)}: ${elementDescription(context)} cannot accept text.`;
+  }
+  return `Cannot fill ${context.state} field ${labelForContext(context)}: ${elementDescription(context)} is not editable.`;
+}
+var FillTargetNotEditableError = class extends Error {
+  fillTarget;
+  constructor(context) {
+    super(formatFillTargetNotEditableMessage(context));
+    this.name = "FillTargetNotEditableError";
+    this.fillTarget = context;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFillTargetNotEditableError(error) {
+  if (error instanceof FillTargetNotEditableError) return true;
+  if (!isRecord(error) || error.name !== "FillTargetNotEditableError") return false;
+  if (!isRecord(error.fillTarget)) return false;
+  const context = error.fillTarget;
+  return typeof context.ref === "string" && typeof context.tagName === "string" && (context.state === "readonly" || context.state === "disabled" || context.state === "not-fillable");
+}
+function formatFillTargetNotEditableRecovery(error, toolName = "browser_fill_form") {
+  const context = error.fillTarget;
+  const action = toolName === "browser_type" ? "type into" : "fill";
+  if (context.state === "not-fillable") {
+    return [
+      `Error: ${toolName} cannot ${action} target ${labelForContext(context)}: ${elementDescription(context)} cannot accept typed text.`,
+      `Do not retry ${toolName} for this ref. Call browser_snapshot and choose the actual editable input or textarea. If the target is a dropdown, use browser_select_option or click the dropdown and select an option.`
+    ].join(" ");
+  }
+  return [
+    `Error: ${toolName} cannot ${action} ${context.state} field ${labelForContext(context)}: ${elementDescription(context)} is not editable.`,
+    `Do not retry ${toolName} for this ref. Call browser_snapshot and choose an editable input or textarea for the same requirement, or complete the prerequisite that unlocks this field first.`
+  ].join(" ");
+}
 function isMCPContentWithImages(result) {
   return typeof result === "object" && result !== null && "text" in result && "images" in result && Array.isArray(result.images) && result.images.length > 0;
 }
@@ -50212,6 +50920,31 @@ function formatEmptyPressKeyRecovery() {
     'Do not retry with an empty string. Use a Playwright key such as "Enter", "Escape", "Tab", "ArrowDown", or use browser_type when you need to enter text.'
   ].join(" ");
 }
+function normalizeRef(ref2) {
+  const trimmed = ref2?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function formatEmptyRefRecovery(toolName) {
+  return [
+    `Error: ${toolName} requires a non-empty element ref from the latest browser_snapshot.`,
+    'Do not retry with an empty string. Call browser_snapshot and use a concrete ref such as "e42", or use the coordinate path when that tool supports coordinates.'
+  ].join(" ");
+}
+function extractWaitingAriaRef(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.match(/waiting for locator\('aria-ref=([^']+)'\)/)?.[1];
+}
+function isStaleAriaRefActionTimeout(error, action) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes(`${action}: Timeout`) && message.includes("waiting for locator('aria-ref=") && !message.includes("locator resolved to <");
+}
+function formatStaleRefActionRecovery(toolName, ref2, element) {
+  const label = element ? ` for "${element}"` : "";
+  return [
+    `Error: ${toolName} could not find ref ${ref2}${label} in the current page snapshot.`,
+    "Do not retry the same ref. Call browser_snapshot and choose a fresh ref, or use the coordinate path when that tool supports coordinates."
+  ].join(" ");
+}
 function isSelectOptionNonSelectError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("selectOption:") && message.includes("Element is not a <select>");
@@ -50219,6 +50952,35 @@ function isSelectOptionNonSelectError(error) {
 function isMissingDownloadTempFileError(message) {
   return /\bENOENT:\s+no such file or directory,\s+open\b/.test(message) && message.includes("/playwright-downloads-");
 }
+function isNavigateDownloadStartingError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /\bgoto:\s+Download is starting\b/.test(message);
+}
+function formatNavigateDownloadStartingRecovery() {
+  return [
+    "Error: browser_navigate started a file download instead of loading a page.",
+    "Do not retry browser_navigate for the same URL. Call browser_list_downloads to find the captured file, then use browser_read_download or browser_pdf_read to inspect it."
+  ].join(" ");
+}
+function isRelativeNavigateTarget(url) {
+  const trimmed = url.trim();
+  return trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("?") || trimmed.startsWith("#");
+}
+function isHttpUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function formatRelativeNavigateRecovery(url, currentUrl) {
+  const baseDescription = currentUrl ? `current page URL is "${currentUrl}"` : "current page URL is unavailable";
+  return [
+    `Error: browser_navigate received relative URL "${url}", but the ${baseDescription}.`,
+    "Use an absolute http(s) URL, or call browser_snapshot first if the current page needs to be inspected before navigating."
+  ].join(" ");
+}
 function formatSelectOptionNonSelectRecovery(ref2, value, element) {
   return [
     `Error: browser_select_option can only operate on native <select> elements; ref ${ref2} for "${element}" resolved to a custom dropdown or combobox.`,
@@ -50676,11 +51438,38 @@ var BrowserToolExecutor = class {
   }
   // ==================== Navigation ====================
   async navigate(url) {
-    ensureAllowedHost(url, this.allowedHosts);
-    const rawResult = await this.client.navigate(url, { signal: this.currentSignal });
+    const navigationUrl = await this.resolveNavigateUrl(url);
+    if (navigationUrl.kind === "recovery") {
+      return navigationUrl.message;
+    }
+    ensureAllowedHost(navigationUrl.url, this.allowedHosts);
+    let rawResult;
+    try {
+      rawResult = await this.client.navigate(navigationUrl.url, { signal: this.currentSignal });
+    } catch (error) {
+      if (isNavigateDownloadStartingError(error)) {
+        return formatNavigateDownloadStartingRecovery();
+      }
+      throw error;
+    }
     const result = withRecoveryNotice(this.client, rawResult, this.logger);
     return this.formatNavigateResult(result);
   }
+  async resolveNavigateUrl(url) {
+    const trimmedUrl = url.trim();
+    if (!isRelativeNavigateTarget(trimmedUrl)) {
+      return { kind: "url", url: trimmedUrl };
+    }
+    const currentUrl = await this.client.getCurrentUrl({ signal: this.currentSignal }).catch(() => void 0);
+    if (!currentUrl || !isHttpUrl(currentUrl)) {
+      return { kind: "recovery", message: formatRelativeNavigateRecovery(trimmedUrl, currentUrl) };
+    }
+    try {
+      return { kind: "url", url: new URL(trimmedUrl, currentUrl).toString() };
+    } catch {
+      return { kind: "recovery", message: formatRelativeNavigateRecovery(trimmedUrl, currentUrl) };
+    }
+  }
   async navigateBack() {
     const result = await this.client.navigateBack({ signal: this.currentSignal });
     return this.formatNavigateResult(result);
@@ -50930,7 +51719,7 @@ ${effectiveShowCoordinateGrid ? "Coordinate grid enabled - read coordinates from
       elementHints,
       matchedHintIds: void 0
     };
-    let semanticText = formatSemanticSnapshot(yaml, snapshotOpts);
+    let semanticText = await formatSnapshotMaybeOffloaded(yaml, snapshotOpts);
     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.]
@@ -50985,6 +51774,10 @@ ${body}
    * Returns a structured result with the message and optional created hint metadata.
    */
   async hint(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return { message: formatEmptyRefRecovery("browser_hint") };
+    }
     if (!this.hintProvider) {
       return { message: "Element hints are not available in this environment." };
     }
@@ -50998,9 +51791,9 @@ ${body}
       return { message: "Cannot create hint: no recent snapshot available. Take a snapshot first." };
     }
     const elements = parseSnapshot(lastYaml);
-    const fpResult = fingerprintForHint(elements, opts.ref);
+    const fpResult = fingerprintForHint(elements, ref2);
     if (!fpResult) {
-      return { message: `Cannot create hint: element ref "${opts.ref}" not found in the current snapshot.` };
+      return { message: `Cannot create hint: element ref "${ref2}" not found in the current snapshot.` };
     }
     if (opts.invalidate) {
       if (!opts.reason) {
@@ -51019,7 +51812,7 @@ ${body}
         fingerprintHash: fpResult.hash,
         reason: opts.reason
       });
-      return { message: `Hint on [${opts.ref}] invalidated: ${opts.reason}` };
+      return { message: `Hint on [${ref2}] invalidated: ${opts.reason}` };
     }
     if (!opts.frontmatter) {
       return { message: "Cannot create hint: frontmatter is required." };
@@ -51064,7 +51857,7 @@ ${body}
     });
     const anchorNote = fpResult.anchoredToParent ? ` (anchored to ${fpResult.anchor.role} "${fpResult.anchor.text ?? ""}")` : "";
     return {
-      message: `Hint created on [${opts.ref}]${anchorNote}: (${category}: ${opts.frontmatter})`,
+      message: `Hint created on [${ref2}]${anchorNote}: (${category}: ${opts.frontmatter})`,
       created: {
         id: created.id,
         frontmatter: opts.frontmatter,
@@ -51075,10 +51868,11 @@ ${body}
     };
   }
   async screenshot(opts) {
+    const ref2 = normalizeRef(opts?.ref);
     const img = await this.client.takeScreenshot({
       fullPage: opts?.fullPage,
       element: opts?.element,
-      ref: opts?.ref,
+      ref: ref2,
       type: opts?.type ?? "jpeg",
       label: opts?.label,
       signal: this.currentSignal
@@ -51099,9 +51893,10 @@ ${body}
     return `Screenshot captured${opts?.label ? ` (${opts.label})` : ""}: ${img ? "success" : "no screenshot"}`;
   }
   async evaluate(opts) {
+    const ref2 = normalizeRef(opts.ref);
     const result = await this.client.evaluate(opts.expression, {
       label: opts.label,
-      ref: opts.ref,
+      ref: ref2,
       signal: this.currentSignal
     });
     return typeof result === "string" ? result : JSON.stringify(result, null, 2);
@@ -51119,7 +51914,7 @@ ${body}
   }
   // ==================== Interaction ====================
   async click(opts) {
-    const { ref: ref2 } = opts;
+    const ref2 = normalizeRef(opts.ref);
     let x2 = opts.x;
     let y2 = opts.y;
     if (x2 === 0 && y2 === 0) {
@@ -51135,29 +51930,40 @@ ${body}
     const useCoordinates = !ref2 && x2 !== void 0 && y2 !== void 0;
     const clickVerb = opts.doubleClick ? "Double-clicked" : "Clicked";
     const actionDesc = useCoordinates ? `${clickVerb} "${opts.element}" at (${x2}, ${y2})` : `${clickVerb} "${opts.element}" via ref ${ref2}`;
-    this.lastReplayableAction = { description: actionDesc, thunk: () => this.click(opts) };
+    this.lastReplayableAction = {
+      description: actionDesc,
+      thunk: () => this.click({ ...opts, ref: ref2 })
+    };
     let clickedElement;
     let fallbackUsed = false;
     const preClickUrl = useCoordinates && this.augmentorProvider ? await this.client.getCurrentUrl({ signal: this.currentSignal }).catch(() => void 0) : void 0;
-    const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
-      if (useCoordinates) {
-        const coordResult = await this.client.clickAtCoordinates(x2, y2, opts.element, {
-          doubleClick: opts.doubleClick,
-          modifiers: opts.modifiers,
-          signal: this.currentSignal
-        });
-        clickedElement = coordResult.clickedElement;
-      } else {
-        const refResult = await this.client.click(ref2, opts.element, {
-          doubleClick: opts.doubleClick,
-          button: opts.button,
-          modifiers: opts.modifiers,
-          signal: this.currentSignal
-        });
-        clickedElement = refResult.clickedElement;
-        fallbackUsed = refResult.fallbackUsed;
+    let diffText;
+    try {
+      ({ diffText } = await this.withSemanticDiff(actionDesc, async () => {
+        if (useCoordinates) {
+          const coordResult = await this.client.clickAtCoordinates(x2, y2, opts.element, {
+            doubleClick: opts.doubleClick,
+            modifiers: opts.modifiers,
+            signal: this.currentSignal
+          });
+          clickedElement = coordResult.clickedElement;
+        } else {
+          const refResult = await this.client.click(ref2, opts.element, {
+            doubleClick: opts.doubleClick,
+            button: opts.button,
+            modifiers: opts.modifiers,
+            signal: this.currentSignal
+          });
+          clickedElement = refResult.clickedElement;
+          fallbackUsed = refResult.fallbackUsed;
+        }
+      }));
+    } catch (error) {
+      if (!useCoordinates && ref2 && isStaleAriaRefActionTimeout(error, "click")) {
+        return formatStaleRefActionRecovery("browser_click", ref2, opts.element);
       }
-    });
+      throw error;
+    }
     if (useCoordinates) {
       await this.emitAugmentorSignal("coordinate_click", x2, y2, preClickUrl ?? "");
     } else {
@@ -51173,36 +51979,56 @@ ${body}
     return withRecoveryNoticeMCP(this.client, result, this.logger);
   }
   async type(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_type");
+    }
     const submitNote = opts.submit ? " and submitted" : "";
     const actionDesc = `Typed "${opts.text}" into "${opts.element}"${submitNote}`;
-    this.lastReplayableAction = { description: actionDesc, thunk: () => this.type(opts) };
-    if (opts.submit) {
-      const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
-        await this.client.type(opts.ref, opts.text, opts.element, opts.submit, {
-          delay: opts.delay,
-          signal: this.currentSignal
+    this.lastReplayableAction = {
+      description: actionDesc,
+      thunk: () => this.type({ ...opts, ref: ref2 })
+    };
+    try {
+      if (opts.submit) {
+        const { diffText } = await this.withSemanticDiff(actionDesc, async () => {
+          await this.client.type(ref2, opts.text, opts.element, opts.submit, {
+            delay: opts.delay,
+            signal: this.currentSignal
+          });
         });
+        return withRecoveryNoticeMCP(this.client, diffText, this.logger);
+      }
+      await this.client.type(ref2, opts.text, opts.element, opts.submit, {
+        delay: opts.delay,
+        signal: this.currentSignal
       });
-      return withRecoveryNoticeMCP(this.client, diffText, this.logger);
+      return withRecoveryNotice(this.client, actionDesc, this.logger);
+    } catch (error) {
+      if (isFillTargetNotEditableError(error)) {
+        return formatFillTargetNotEditableRecovery(error, "browser_type");
+      }
+      throw error;
     }
-    await this.client.type(opts.ref, opts.text, opts.element, opts.submit, {
-      delay: opts.delay,
-      signal: this.currentSignal
-    });
-    return withRecoveryNotice(this.client, actionDesc, this.logger);
   }
   async hover(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_hover");
+    }
     const { diffText } = await this.withSemanticDiff(
-      `Hovered over "${opts.element}" via ref ${opts.ref}`,
+      `Hovered over "${opts.element}" via ref ${ref2}`,
       async () => {
-        await this.client.hover(opts.ref, opts.element, { signal: this.currentSignal });
+        await this.client.hover(ref2, opts.element, { signal: this.currentSignal });
       }
     );
     return diffText;
   }
   async drag(opts) {
+    const startRef = normalizeRef(opts.startRef);
+    const endRef = normalizeRef(opts.endRef);
     const useCoordinates = opts.startX !== void 0 && opts.startY !== void 0 && opts.endX !== void 0 && opts.endY !== void 0;
-    const useRefs = opts.startRef !== void 0 && opts.endRef !== void 0;
+    const useRefs = startRef !== void 0 && endRef !== void 0;
     if (!useCoordinates && !useRefs) {
       return "Error: Provide either startRef + endRef, or all four coordinates (startX, startY, endX, endY)";
     }
@@ -51221,7 +52047,7 @@ ${body}
           { signal: this.currentSignal }
         );
       } else {
-        await this.client.drag(opts.startRef, opts.startElement, opts.endRef, opts.endElement, {
+        await this.client.drag(startRef, opts.startElement, endRef, opts.endElement, {
           signal: this.currentSignal
         });
       }
@@ -51247,35 +52073,63 @@ ${body}
     return withRecoveryNotice(this.client, `Pressed ${key}`, this.logger);
   }
   async fillForm(fields) {
-    const { diffText } = await this.withSemanticDiff(
-      `Filled ${fields.length} form field(s)`,
-      async () => {
-        await this.client.fillForm(fields, { signal: this.currentSignal });
+    const normalizedFields = fields.map((field) => ({
+      ...field,
+      ref: normalizeRef(field.ref) ?? ""
+    }));
+    if (normalizedFields.some((field) => field.ref.length === 0)) {
+      return formatEmptyRefRecovery("browser_fill_form");
+    }
+    try {
+      const { diffText } = await this.withSemanticDiff(
+        `Filled ${fields.length} form field(s)`,
+        async () => {
+          await this.client.fillForm(normalizedFields, { signal: this.currentSignal });
+        }
+      );
+      return diffText;
+    } catch (error) {
+      if (isFillTargetNotEditableError(error)) {
+        return formatFillTargetNotEditableRecovery(error);
+      }
+      if (isStaleAriaRefActionTimeout(error, "fill")) {
+        const staleRef = extractWaitingAriaRef(error);
+        const field = normalizedFields.find((candidate) => candidate.ref === staleRef) ?? normalizedFields[0];
+        return formatStaleRefActionRecovery(
+          "browser_fill_form",
+          staleRef ?? field?.ref ?? "unknown",
+          field?.element
+        );
       }
-    );
-    return diffText;
+      throw error;
+    }
   }
   async selectOption(opts) {
+    const ref2 = normalizeRef(opts.ref);
+    if (!ref2) {
+      return formatEmptyRefRecovery("browser_select_option");
+    }
     try {
       const { diffText } = await this.withSemanticDiff(
         `Selected "${opts.value}" in "${opts.element}"`,
         async () => {
-          await this.client.selectOption(opts.ref, opts.value, opts.element, { signal: this.currentSignal });
+          await this.client.selectOption(ref2, opts.value, opts.element, { signal: this.currentSignal });
         }
       );
       return diffText;
     } catch (error) {
       if (isSelectOptionNonSelectError(error)) {
-        return formatSelectOptionNonSelectRecovery(opts.ref, opts.value, opts.element);
+        return formatSelectOptionNonSelectRecovery(ref2, opts.value, opts.element);
       }
       throw error;
     }
   }
   async fileUpload(paths, ref2) {
+    const normalizedRef = normalizeRef(ref2);
     const { diffText } = await this.withSemanticDiff(
       `Uploaded ${paths.length} file(s)`,
       async () => {
-        await this.client.fileUpload(paths, { ref: ref2, signal: this.currentSignal });
+        await this.client.fileUpload(paths, { ref: normalizedRef, signal: this.currentSignal });
       }
     );
     return diffText;
@@ -51284,15 +52138,17 @@ ${body}
   async scroll(opts) {
     let result;
     let label;
-    if (opts.toRef) {
+    const withinRef = normalizeRef(opts.withinRef);
+    const toRef = normalizeRef(opts.toRef);
+    if (toRef) {
       result = await this.client.scroll(
         opts.direction,
         opts.amount,
-        opts.withinRef,
-        opts.toRef,
+        withinRef,
+        toRef,
         { signal: this.currentSignal }
       );
-      label = `toRef=${opts.toRef}`;
+      label = `toRef=${toRef}`;
     } else if (opts.x !== void 0 && opts.y !== void 0) {
       if (opts.x === 0 && opts.y === 0) {
         return "Error: Coordinate scroll at (0, 0) is invalid. The coordinates were likely defaulted instead of intentionally chosen. Use direction-based scroll, scroll to a ref, or provide real coordinates before retrying.";
@@ -51309,11 +52165,11 @@ ${body}
       result = await this.client.scroll(
         opts.direction,
         opts.amount,
-        opts.withinRef,
+        withinRef,
         void 0,
         { signal: this.currentSignal }
       );
-      label = `direction=${opts.direction}${opts.amount ? `, amount=${opts.amount}` : ""}${opts.withinRef ? `, withinRef=${opts.withinRef}` : ""}`;
+      label = `direction=${opts.direction}${opts.amount ? `, amount=${opts.amount}` : ""}${withinRef ? `, withinRef=${withinRef}` : ""}`;
     }
     const scrollInfo = typeof result === "object" && result !== null ? result.scrollInfo : void 0;
     if (scrollInfo && !scrollInfo.moved) {
@@ -51467,6 +52323,9 @@ ${header}
       if (message === "No downloads captured during this session.") {
         return `${message} Use browser_list_downloads after triggering a download, or try browser_pdf_read if the file opened inline instead of downloading.`;
       }
+      if (downloadId === 0 && message === "Download #0 not found. Use browser_list_downloads to see available downloads.") {
+        return "Download #0 was not found. Download ids start at 1; call browser_list_downloads and use the listed id, or omit downloadId to read the most recent download.";
+      }
       if (isMissingDownloadTempFileError(message)) {
         const label = downloadId !== null && downloadId !== void 0 ? `Download #${downloadId}` : "The most recent download";
         return `${label} was captured, but its temporary file is no longer available. Trigger the download again, then call browser_list_downloads and browser_read_download with the new id.`;
@@ -51684,7 +52543,7 @@ ${recoveryHint}`;
       await fs22.writeFile(snapshotFilePath, yaml, "utf-8");
     } catch {
     }
-    const semanticText = formatSemanticSnapshot(yaml, {
+    const semanticText = await formatSnapshotMaybeOffloaded(yaml, {
       snapshotFilePath,
       currentTime: (/* @__PURE__ */ new Date()).toISOString(),
       capturedToasts: this.client.getCapturedToasts?.() ?? [],
@@ -54653,6 +55512,42 @@ function resolveBrowserContextRequestUrl(url, pageUrl) {
     return url;
   }
 }
+function isRouteAlreadyHandledError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Route is already handled");
+}
+function createSingleUseContextRouteHandle(route, logger2) {
+  let handled = false;
+  const runOnce = async (action, fn) => {
+    if (handled) {
+      logger2.debug("[ContextRoute] Ignoring duplicate route action", { action });
+      return;
+    }
+    handled = true;
+    try {
+      await fn();
+    } catch (error) {
+      if (isRouteAlreadyHandledError(error)) {
+        logger2.debug("[ContextRoute] Route was already handled by Playwright", {
+          action,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return;
+      }
+      throw error;
+    }
+  };
+  return {
+    fulfill: (opts) => runOnce("fulfill", () => route.fulfill(opts)),
+    continue: (opts) => runOnce("continue", () => route.continue(opts)),
+    request: () => ({
+      url: () => route.request().url(),
+      method: () => route.request().method(),
+      postData: () => route.request().postData(),
+      headers: () => route.request().headers()
+    })
+  };
+}
 var TOAST_SNAPSHOT_TTL = 5;
 function formatMcpResponse(input) {
   const lines = [];
@@ -54842,6 +55737,16 @@ function normalizeDateInputValue(value) {
   }
   return value;
 }
+var OperationTimeoutError = class extends Error {
+  label;
+  timeoutMs;
+  constructor(label, timeoutMs) {
+    super(`${label} timed out after ${timeoutMs}ms`);
+    this.name = "OperationTimeoutError";
+    this.label = label;
+    this.timeoutMs = timeoutMs;
+  }
+};
 function asEmitter(page) {
   return page;
 }
@@ -54861,6 +55766,15 @@ function stripNewListeners(page, event, baseline) {
   }
   return stripped;
 }
+var runCodePageRequestMethods = /* @__PURE__ */ new Set([
+  "delete",
+  "fetch",
+  "get",
+  "head",
+  "patch",
+  "post",
+  "put"
+]);
 function logLateRunCodeWaitRejection(logger2, kind, promise) {
   promise.catch((err) => {
     logger2.debug(`[DirectPlaywright] runCode ${kind} wait rejected after call`, {
@@ -54868,6 +55782,95 @@ function logLateRunCodeWaitRejection(logger2, kind, promise) {
     });
   });
 }
+function guardRunCodeFetch(logger2) {
+  return (...args) => {
+    const promise = globalThis.fetch(...args);
+    promise.catch((err) => {
+      logger2.debug("[DirectPlaywright] runCode fetch rejected after call", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    return promise;
+  };
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && typeof value.catch === "function";
+}
+function logLateRunCodePageRequestRejection(logger2, method, url, promise) {
+  promise.catch((err) => {
+    logger2.debug("[DirectPlaywright] runCode page.request rejected after call", {
+      method,
+      url: url.slice(0, 200),
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+}
+function guardRunCodePageRequestContext(request2, getPageUrl, logger2) {
+  if (request2 === null || typeof request2 !== "object" && typeof request2 !== "function") {
+    return request2;
+  }
+  const functionCache = /* @__PURE__ */ new Map();
+  return new Proxy(request2, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const cached = functionCache.get(property);
+      if (cached) {
+        return cached;
+      }
+      if (!runCodePageRequestMethods.has(property)) {
+        const bound = value.bind(target);
+        functionCache.set(property, bound);
+        return bound;
+      }
+      const method = property;
+      const guarded = (...args) => {
+        const requestArgs = [...args];
+        const originalUrl = requestArgs[0];
+        let requestUrl = null;
+        if (typeof originalUrl === "string") {
+          requestUrl = resolveBrowserContextRequestUrl(originalUrl, getPageUrl());
+          requestArgs[0] = requestUrl;
+        }
+        const result = value.apply(target, requestArgs);
+        if (isPromiseLike(result) && requestUrl !== null) {
+          logLateRunCodePageRequestRejection(logger2, method, requestUrl, result);
+        }
+        return result;
+      };
+      functionCache.set(property, guarded);
+      return guarded;
+    }
+  });
+}
+function guardRunCodePageRequest(page, logger2) {
+  const guardedRequest = guardRunCodePageRequestContext(
+    page.request,
+    () => page.url(),
+    logger2
+  );
+  const functionCache = /* @__PURE__ */ new Map();
+  return new Proxy(page, {
+    get(target, property, receiver) {
+      if (property === "request") {
+        return guardedRequest;
+      }
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const cached = functionCache.get(property);
+      if (cached) {
+        return cached;
+      }
+      const bound = value.bind(page);
+      functionCache.set(property, bound);
+      return bound;
+    }
+  });
+}
 function guardFileChooserWaitForEvent(page, logger2) {
   const originalWaitForEvent = page.waitForEvent;
   let guarded = 0;
@@ -55297,10 +56300,7 @@ var PlaywrightClient = class _PlaywrightClient {
       return await Promise.race([
         operation,
         new Promise((_, reject) => {
-          timer = setTimeout(
-            () => reject(new Error(`${label} timed out after ${timeoutMs}ms`)),
-            timeoutMs
-          );
+          timer = setTimeout(() => reject(new OperationTimeoutError(label, timeoutMs)), timeoutMs);
         })
       ]);
     } finally {
@@ -55398,6 +56398,20 @@ var PlaywrightClient = class _PlaywrightClient {
   // Tracing state
   tracingActive = false;
   traceDir = null;
+  // Flushed trace chunk paths (one per browser context). Tracing is bound to a
+  // single Playwright context; when the context is swapped/recreated mid-run we
+  // flush the in-progress trace to disk here and restart tracing on the new
+  // context, so the run-level trace survives the swap instead of being discarded.
+  traceChunks = [];
+  // Every trace temp dir created this session (incl. chunks whose flush failed,
+  // so they aren't in traceChunks) — swept on disconnect so none leak.
+  allTraceDirs = /* @__PURE__ */ new Set();
+  // Context routes (e.g. Cloudflare Access scoped-header injection) last applied
+  // via setupContextRoutes(). Route interception is per-context and is dropped
+  // when the context is recreated; we remember the routes so auto-recovery paths
+  // (restoreBrowser) can re-arm them — otherwise the edge would bounce
+  // post-recovery requests to a login page.
+  storedContextRoutes = [];
   // Video recording state.
   // The screencast encoder is the single source of truth for the recorded
   // file: while it lives, `videoDir`/`videoPath` derive from it. Before the
@@ -55649,6 +56663,17 @@ var PlaywrightClient = class _PlaywrightClient {
   supportsContextSwap() {
     return !this.extensionsEnabled && (!!this.browser || !!this.browserLease);
   }
+  /**
+   * Replace the browser context (e.g. to apply fresh storage state on re-auth),
+   * keeping the same browser. Contract for context-bound state:
+   *  - Tracing AUTO-resumes here: the in-progress trace is flushed to a chunk
+   *    first (recoverable), then restarted on the new context.
+   *  - Context routes (e.g. CF Access scoped headers) are NOT re-armed here —
+   *    the caller must re-apply them via setupContextRoutes after the swap,
+   *    because the swap may intentionally change the headers (new credential).
+   *    (Crash-recovery in restoreBrowser DOES auto re-arm from stored routes,
+   *    since the headers are unchanged there.)
+   */
   async swapContext(options) {
     if (!this.supportsContextSwap()) {
       throw new Error(
@@ -55672,14 +56697,9 @@ var PlaywrightClient = class _PlaywrightClient {
       this.logger.info("[DirectPlaywright] Stopping screencast frame delivery for context swap");
       await this._stopScreencastFrameDelivery();
     }
-    if (this.tracingActive && this.context) {
-      try {
-        await this.context.tracing.stop();
-      } catch {
-      } finally {
-        this.tracingActive = false;
-        this.traceDir = null;
-      }
+    const resumeTracingAfterSwap = this.tracingActive && !!this.context;
+    if (resumeTracingAfterSwap) {
+      await this.flushTraceChunk();
     }
     this.contextClosedIntentionally = true;
     this.pageClosedIntentionally = true;
@@ -55771,6 +56791,13 @@ var PlaywrightClient = class _PlaywrightClient {
     if (wasScreencasting && this.page && this.screencastHandler) {
       await this.startScreencast(this.screencastHandler);
     }
+    if (resumeTracingAfterSwap) {
+      await this.beginTracingOnContext().catch((err) => {
+        this.logger.warn("[DirectPlaywright] Failed to resume tracing after context swap", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
     this.logger.info("[DirectPlaywright] Context swapped successfully");
   }
   /**
@@ -56103,20 +57130,22 @@ var PlaywrightClient = class _PlaywrightClient {
         }
         this._downloadDir = null;
       }
-      if (this.traceDir) {
-        try {
-          await fs4.rm(this.traceDir, { recursive: true, force: true });
-          this.logger.debug("[DirectPlaywright] Cleaned up trace directory", {
-            traceDir: this.traceDir
-          });
-        } catch (err) {
-          this.logger.warn("[DirectPlaywright] Failed to clean up trace directory", {
-            traceDir: this.traceDir,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        this.traceDir = null;
-      }
+      const traceDirsToClean = new Set(this.allTraceDirs);
+      if (this.traceDir) traceDirsToClean.add(this.traceDir);
+      await Promise.allSettled(
+        [...traceDirsToClean].map(
+          (dir) => fs4.rm(dir, { recursive: true, force: true }).catch(
+            (err) => this.logger.warn("[DirectPlaywright] Failed to clean up trace directory", {
+              traceDir: dir,
+              error: err instanceof Error ? err.message : String(err)
+            })
+          )
+        )
+      );
+      this.traceDir = null;
+      this.traceChunks = [];
+      this.allTraceDirs.clear();
+      this.storedContextRoutes = [];
       this._capturedDownloads = [];
       this._downloadCounter = 0;
       this._lastReportedDownloadIndex = 0;
@@ -56469,9 +57498,11 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
     let threwError = null;
     let aborted = runController.signal.aborted;
     let guardedWaits = { fileChooser: 0, request: 0, response: 0 };
+    const guardedFetch = guardRunCodeFetch(this.logger);
+    const guardedPage = guardRunCodePageRequest(page, this.logger);
     try {
       if (!aborted) {
-        const fn = new Function("page", `return (async () => { ${code} })()`);
+        const fn = new Function("page", "fetch", `return (async () => { ${code} })()`);
         const abortPromise = new Promise((_, reject) => {
           runController.signal.addEventListener(
             "abort",
@@ -56479,7 +57510,7 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
             { once: true }
           );
         });
-        const inner = fn(page);
+        const inner = fn(guardedPage, guardedFetch);
         inner.catch((err) => {
           this.logger.debug("[DirectPlaywright] runCode orphan rejected after race", {
             error: err instanceof Error ? err.message : String(err)
@@ -56698,6 +57729,16 @@ ${warning}` : ""}`,
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      if (isPlaywrightTargetClosedError(err)) {
+        throw toBrowserActionTargetClosedError(err, {
+          operation: "click",
+          ref: ref2,
+          elementDesc,
+          lastKnownUrl: this.lastKnownUrl,
+          pendingCrashType: this._pendingCrashType,
+          pendingCrashUrl: this._pendingCrashUrl
+        });
+      }
       const isTimeout = message.includes("Timeout") || message.includes("timeout");
       if (isTimeout && preClickBox) {
         const centerX = Math.round(preClickBox.x + preClickBox.width / 2);
@@ -56849,6 +57890,7 @@ ${warning}` : ""}`,
     const dialogMsg = this.getPendingDialogMessage();
     if (dialogMsg) throw new Error(dialogMsg);
     const locator = await this.resolveRef(ref2);
+    await assertFillTargetEditable(locator, ref2, elementDesc);
     const timeout = opts?.timeoutMs ?? TIMEOUTS.TYPE;
     const inputType = await locator.evaluate((node) => node instanceof HTMLInputElement ? node.type : null).catch((err) => {
       this.logger.debug("[DirectPlaywright] Failed to inspect input type before typing", {
@@ -57840,13 +58882,58 @@ ${warning}` : ""}`,
   }
   // ================ TRACING ================
   async startTracing(_opts) {
-    const context = await this.getContext();
     this.logger.info("[DirectPlaywright] Starting trace recording");
-    this.traceDir = path5.join(this.tmpBaseDir, `playwright-trace-${Date.now()}`);
-    await fs4.mkdir(this.traceDir, { recursive: true });
-    await context.tracing.start({ screenshots: true, snapshots: true });
+    this.traceChunks = [];
+    this.allTraceDirs.clear();
+    await this.beginTracingOnContext();
+  }
+  /**
+   * Start a Playwright trace on the current context. Used both for the initial
+   * `startTracing()` and to resume tracing after a context swap. `traceDir` /
+   * `tracingActive` are set ONLY after `tracing.start()` resolves — a thrown
+   * start must not leave `traceDir` set, or a later `stopTracing()` would target
+   * a context that never started tracing ("Must start tracing before stopping").
+   */
+  async beginTracingOnContext() {
+    const context = await this.getContext();
+    const traceDir = path5.join(
+      this.tmpBaseDir,
+      `playwright-trace-${Date.now()}-${this.traceChunks.length}`
+    );
+    await fs4.mkdir(traceDir, { recursive: true });
+    try {
+      await context.tracing.start({ screenshots: true, snapshots: true });
+    } catch (err) {
+      await fs4.rm(traceDir, { recursive: true, force: true }).catch(() => {
+      });
+      throw err;
+    }
+    this.traceDir = traceDir;
+    this.allTraceDirs.add(traceDir);
     this.tracingActive = true;
   }
+  /**
+   * Flush the in-progress trace on the current context to disk and record the
+   * chunk. Returns the chunk path, or null when tracing isn't active. Stopping
+   * WITH a path preserves the trace; stopping without one discards it. Errors are
+   * swallowed (best-effort) so a failed flush never blocks a context swap.
+   */
+  async flushTraceChunk() {
+    if (!this.tracingActive || !this.context || !this.traceDir) return null;
+    const chunkPath = path5.join(this.traceDir, "trace.zip");
+    try {
+      await this.context.tracing.stop({ path: chunkPath });
+      this.traceChunks.push(chunkPath);
+      return chunkPath;
+    } catch (err) {
+      this.logger.warn("[DirectPlaywright] Failed to flush trace chunk", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    } finally {
+      this.tracingActive = false;
+    }
+  }
   async traceGroup(name) {
     if (!this.tracingActive) return;
     const context = await this.getContext();
@@ -57866,20 +58953,26 @@ ${warning}` : ""}`,
    * The trace.zip can be viewed at https://trace.playwright.dev/
    */
   async stopTracing(_opts) {
-    const context = await this.getContext();
-    if (!this.traceDir) throw new Error("Tracing not started");
     this.logger.info("[DirectPlaywright] Stopping trace recording");
-    const tracePath = path5.join(this.traceDir, "trace.zip");
-    await context.tracing.stop({ path: tracePath });
-    this.tracingActive = false;
+    await this.flushTraceChunk();
+    if (this.traceChunks.length === 0) {
+      throw new Error("No trace chunks captured (tracing not started, or all flushes failed)");
+    }
+    const chunks = [...this.traceChunks];
+    if (chunks.length > 1) {
+      this.logger.info("[DirectPlaywright] Captured multiple trace chunks across context swaps", {
+        chunkCount: chunks.length
+      });
+    }
     return {
-      trace: tracePath,
+      trace: chunks[0],
+      traces: chunks,
       network: "",
       // Playwright bundles network data in trace.zip (not separate file)
       resources: "",
       // Playwright bundles resources in trace.zip (not separate file)
-      directory: this.traceDir,
-      legend: `Trace saved to ${tracePath}`
+      directory: path5.dirname(chunks[0]),
+      legend: `Trace saved to ${chunks[0]}`
     };
   }
   // ================ PRIVATE: Accessibility Snapshot ================
@@ -57998,11 +59091,22 @@ ${warning}` : ""}`,
           result = await this.raceAgainstSignal(
             "snapshot:aria",
             signal,
-            () => page.ariaSnapshot({ mode: "ai" })
+            () => this.withOperationTimeout(
+              page.ariaSnapshot({ mode: "ai" }),
+              TIMEOUTS.ARIA_SNAPSHOT_CAP,
+              "snapshot:aria"
+            )
           );
           break;
         } catch (err) {
           if (signal?.aborted) return void 0;
+          if (err instanceof OperationTimeoutError && err.label === "snapshot:aria") {
+            this.logger.warn(
+              "[DirectPlaywright] ariaSnapshot exceeded driver cap, using empty fallback",
+              { capMs: TIMEOUTS.ARIA_SNAPSHOT_CAP, attempt }
+            );
+            break;
+          }
           if (attempt < maxRetries) {
             this.logger.debug("[DirectPlaywright] Snapshot attempt failed, retrying", {
               attempt,
@@ -59004,6 +60108,8 @@ Legacy two-step (only if you need to change the action between calls): browser_h
         this.browser = null;
         this.attachContextListeners(this.context);
         await this.createPageWithListeners(this.context, reason);
+        await this.reapplyStoredContextRoutes();
+        await this.resumeTracingOnRecreatedContext();
         await this.restoreUrlAfterRecovery(urlToRestore, crashType);
         await restartScreencastIfNeeded();
         await restartScreencastRecordingIfNeeded();
@@ -59049,6 +60155,8 @@ Legacy two-step (only if you need to change the action between calls): browser_h
         this.attachBrowserListeners(this.browser);
       }
       await this.createPageWithListeners(this.context, reason);
+      await this.reapplyStoredContextRoutes();
+      await this.resumeTracingOnRecreatedContext();
       await this.restoreUrlAfterRecovery(urlToRestore, crashType);
       await restartScreencastIfNeeded();
       await restartScreencastRecordingIfNeeded();
@@ -59222,8 +60330,8 @@ Legacy two-step (only if you need to change the action between calls): browser_h
     });
     await Promise.allSettled(stopPromises);
     this._screencastDisposables.clear();
-    const encoder = this._screencastEncoder;
-    if (!encoder) {
+    const encoder2 = this._screencastEncoder;
+    if (!encoder2) {
       this._screencastEncoder = null;
       this.logger.warn("[DirectPlaywright] Screencast encoder was never started \u2014 no video produced", {
         videoEnabled: this.videoEnabled,
@@ -59231,9 +60339,9 @@ Legacy two-step (only if you need to change the action between calls): browser_h
       });
       return null;
     }
-    this._savedVideoPath = encoder.outputFilePath;
+    this._savedVideoPath = encoder2.outputFilePath;
     this._screencastEncoder = null;
-    const stopResult = await encoder.stop();
+    const stopResult = await encoder2.stop();
     const {
       durationMs,
       receivedFrameCount,
@@ -59475,17 +60583,50 @@ Legacy two-step (only if you need to change the action between calls): browser_h
   // ================ EMULATION ROUTES ================
   async setupContextRoutes(routes) {
     const context = await this.getContext();
+    await this.registerContextRoutes(routes, context);
+    this.storedContextRoutes = routes;
+  }
+  async registerContextRoutes(routes, context) {
     for (const route of routes) {
       await context.route(route.urlPattern, async (pwRoute) => {
-        await route.handler({
-          fulfill: (opts) => pwRoute.fulfill(opts),
-          continue: () => pwRoute.continue(),
-          request: () => ({
-            url: () => pwRoute.request().url(),
-            method: () => pwRoute.request().method(),
-            postData: () => pwRoute.request().postData()
-          })
-        });
+        await route.handler(createSingleUseContextRouteHandle(pwRoute, this.logger));
+      });
+    }
+  }
+  /**
+   * Restart tracing on a freshly recreated (post-crash/recovery) context. The
+   * pre-recovery trace died with the old context and cannot be flushed, so the
+   * best we can do is capture post-recovery activity and ensure the final
+   * stopTracing() targets a context that actually has tracing started.
+   * Best-effort — no-op when tracing wasn't active.
+   */
+  async resumeTracingOnRecreatedContext() {
+    if (!this.tracingActive) return;
+    this.tracingActive = false;
+    await this.beginTracingOnContext().catch((err) => {
+      this.logger.warn("[DirectPlaywright] Failed to resume tracing after browser recovery", {
+        error: err instanceof Error ? err.message : String(err),
+        chunksCapturedSoFar: this.traceChunks.length
+      });
+    });
+  }
+  /**
+   * Re-arm the stored context routes on the current (freshly recreated) context.
+   * Called from recovery paths that build a new context — without this, scoped
+   * header injection (e.g. Cloudflare Access) silently stops after a restore and
+   * the edge redirects subsequent requests to a login page. Best-effort.
+   */
+  async reapplyStoredContextRoutes() {
+    if (this.storedContextRoutes.length === 0 || !this.context) return;
+    try {
+      await this.registerContextRoutes(this.storedContextRoutes, this.context);
+      this.logger.info("[DirectPlaywright] Re-armed context routes on recreated context", {
+        routeCount: this.storedContextRoutes.length
+      });
+    } catch (err) {
+      this.logger.warn("[DirectPlaywright] Failed to re-arm context routes after recreation", {
+        error: err instanceof Error ? err.message : String(err),
+        routeCount: this.storedContextRoutes.length
       });
     }
   }
@@ -59497,33 +60638,93 @@ Legacy two-step (only if you need to change the action between calls): browser_h
     return guessMimeType(filename);
   }
 };
-async function assertFillTargetEditable(locator, ref2, elementDesc) {
-  const probe = await locator.evaluate((el) => {
-    const element = el;
-    const htmlInput = element instanceof HTMLInputElement ? element : null;
-    const htmlTextArea = element instanceof HTMLTextAreaElement ? element : null;
-    const htmlSelect = element instanceof HTMLSelectElement ? element : null;
-    const htmlButton = element instanceof HTMLButtonElement ? element : null;
-    const ariaReadonly = element.getAttribute("aria-readonly") === "true";
-    const ariaDisabled = element.getAttribute("aria-disabled") === "true";
-    const contentEditableFalse = element.getAttribute("contenteditable") === "false";
-    return {
-      readonly: Boolean(
-        htmlInput?.readOnly || htmlTextArea?.readOnly || ariaReadonly || contentEditableFalse
-      ),
-      disabled: Boolean(
-        htmlInput?.disabled || htmlTextArea?.disabled || htmlSelect?.disabled || htmlButton?.disabled || ariaDisabled
-      ),
-      tagName: element.tagName.toLowerCase(),
-      role: element.getAttribute("role")
-    };
+function isPlaywrightTargetClosedError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Target page, context or browser has been closed/i.test(message);
+}
+function toBrowserActionTargetClosedError(error, context) {
+  const label = context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+  const message = error instanceof Error ? error.message : String(error);
+  const wrapped = new Error(`Browser click target closed for ${label}: ${message}`, {
+    cause: error instanceof Error ? error : void 0
+  });
+  wrapped.name = "BrowserActionTargetClosedError";
+  Object.assign(wrapped, { browserActionTargetClosed: context });
+  return wrapped;
+}
+function toFillTargetProbeError(error, context) {
+  const label = context.elementDesc ? `${context.elementDesc} (${context.ref})` : context.ref;
+  const message = error instanceof Error ? error.message : String(error);
+  const wrapped = new Error(`Fill target editability probe failed for ${label}: ${message}`, {
+    cause: error instanceof Error ? error : void 0
   });
-  if (!probe.readonly && !probe.disabled) return;
-  const label = elementDesc ? `${elementDesc} (${ref2})` : ref2;
-  const state = probe.disabled ? "disabled" : "readonly";
+  wrapped.name = "FillTargetProbeError";
+  Object.assign(wrapped, { fillTargetProbe: context });
+  return wrapped;
+}
+async function assertFillTargetEditable(locator, ref2, elementDesc) {
+  let probe;
+  try {
+    probe = await locator.evaluate((el) => {
+      const element = el;
+      const htmlInput = element instanceof HTMLInputElement ? element : null;
+      const htmlTextArea = element instanceof HTMLTextAreaElement ? element : null;
+      const htmlSelect = element instanceof HTMLSelectElement ? element : null;
+      const htmlButton = element instanceof HTMLButtonElement ? element : null;
+      const ariaReadonly = element.getAttribute("aria-readonly") === "true";
+      const ariaDisabled = element.getAttribute("aria-disabled") === "true";
+      const contentEditableFalse = element.getAttribute("contenteditable") === "false";
+      const inputType = htmlInput?.type.toLowerCase() ?? null;
+      const fillableInputTypes = /* @__PURE__ */ new Set([
+        "",
+        "color",
+        "date",
+        "datetime-local",
+        "email",
+        "month",
+        "number",
+        "password",
+        "range",
+        "search",
+        "tel",
+        "text",
+        "time",
+        "url",
+        "week"
+      ]);
+      return {
+        readonly: Boolean(
+          htmlInput?.readOnly || htmlTextArea?.readOnly || ariaReadonly || contentEditableFalse
+        ),
+        disabled: Boolean(
+          htmlInput?.disabled || htmlTextArea?.disabled || htmlSelect?.disabled || htmlButton?.disabled || ariaDisabled
+        ),
+        fillable: Boolean(
+          htmlInput && fillableInputTypes.has(inputType ?? "") || htmlTextArea || element.isContentEditable
+        ),
+        tagName: element.tagName.toLowerCase(),
+        role: element.getAttribute("role"),
+        inputType
+      };
+    });
+  } catch (error) {
+    throw toFillTargetProbeError(error, {
+      ref: ref2,
+      elementDesc,
+      stage: "editability_probe"
+    });
+  }
+  if (!probe.readonly && !probe.disabled && probe.fillable) return;
+  const state = probe.disabled ? "disabled" : probe.readonly ? "readonly" : "not-fillable";
   const tag = probe.tagName ?? "element";
-  const role = probe.role ? ` role=${probe.role}` : "";
-  throw new Error(`Cannot fill ${state} field ${label}: ${tag}${role} is not editable.`);
+  throw new FillTargetNotEditableError({
+    ref: ref2,
+    elementDesc,
+    state,
+    tagName: tag,
+    role: probe.role,
+    ...probe.inputType ? { inputType: probe.inputType } : {}
+  });
 }
 
 export {
@@ -59621,6 +60822,16 @@ export {
   guessMimeType,
   captureElementAtPoint,
   extractElementMetadata,
+  CpuOffloadTimeoutError,
+  CpuOffloadWorkerError,
+  resolveCpuOffloadWorkerPath,
+  CpuOffloadPool,
+  DEFAULT_CPU_OFFLOAD_TIMEOUT_MS,
+  defaultCpuOffloadSize,
+  configureCpuOffload,
+  isCpuOffloadEnabled,
+  shutdownCpuOffload,
+  formatSnapshotMaybeOffloaded,
   ToolAbortedError,
   isMCPContentWithImages,
   coerceResultText,
@@ -59921,4 +61132,4 @@ playwright-extra/dist/index.esm.js:
    * @license MIT
    *)
 */
-//# sourceMappingURL=chunk-AI3Y3AZH.js.map
+//# sourceMappingURL=chunk-7OO3RJYR.js.map