@runcofactor/cli 0.17.0 → 0.18.0

package/dist/{chunk-MO5G5TP5.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,6 +50430,354 @@ 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}`);
@@ -51057,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.]
@@ -51881,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?.() ?? [],
@@ -55075,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;
 }
@@ -55094,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`, {
@@ -55112,6 +55793,84 @@ function guardRunCodeFetch(logger2) {
     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;
@@ -55541,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 {
@@ -55642,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
@@ -55893,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(
@@ -55916,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;
@@ -56015,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");
   }
   /**
@@ -56347,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;
@@ -56714,6 +57499,7 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
     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", "fetch", `return (async () => { ${code} })()`);
@@ -56724,7 +57510,7 @@ Use coordinate-based clicking (x, y) to interact with elements visible in the sc
             { once: true }
           );
         });
-        const inner = fn(page, guardedFetch);
+        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)
@@ -58096,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();
@@ -58122,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 ================
@@ -58254,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,
@@ -59260,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();
@@ -59305,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();
@@ -59478,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,
@@ -59487,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,
@@ -59731,12 +60583,53 @@ 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(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
+      });
+    }
+  }
   // ================ PRIVATE: Download Helpers ================
   formatFileSize(bytes) {
     return formatFileSize(bytes);
@@ -59929,6 +60822,16 @@ export {
   guessMimeType,
   captureElementAtPoint,
   extractElementMetadata,
+  CpuOffloadTimeoutError,
+  CpuOffloadWorkerError,
+  resolveCpuOffloadWorkerPath,
+  CpuOffloadPool,
+  DEFAULT_CPU_OFFLOAD_TIMEOUT_MS,
+  defaultCpuOffloadSize,
+  configureCpuOffload,
+  isCpuOffloadEnabled,
+  shutdownCpuOffload,
+  formatSnapshotMaybeOffloaded,
   ToolAbortedError,
   isMCPContentWithImages,
   coerceResultText,
@@ -60229,4 +61132,4 @@ playwright-extra/dist/index.esm.js:
    * @license MIT
    *)
 */
-//# sourceMappingURL=chunk-MO5G5TP5.js.map
+//# sourceMappingURL=chunk-7OO3RJYR.js.map