@piwitests/reporter 0.54.0 → 0.56.0

package/dist/internal/capture/capture-fixtures.js

@@ -58,7 +58,7 @@ __export(capture_fixtures_exports, {
   stopResourceLedger: () => stopResourceLedger
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
-var path13 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
@@ -489,26 +489,26 @@ function installPickerOverlay(arg) {
     }
   };
   mount(highlight, label, banner);
-  const escJs = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const quoteJs = (s) => `'${JSON.stringify(s).slice(1, -1).replace(/\\"/g, '"').replace(/'/g, "\\'").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}'`;
   const describe = (el) => {
     const tag = (el.tagName || "?").toLowerCase();
     const testId = el.getAttribute && el.getAttribute(testIdAttr);
-    if (testId) return `getByTestId('${escJs(testId)}')`;
+    if (testId) return `getByTestId(${quoteJs(testId)})`;
     if (el.labels && el.labels.length > 0) {
       const labelText = (el.labels[0].textContent || "").replace(/\s+/g, " ").trim().slice(0, 80);
-      if (labelText) return `getByLabel('${escJs(labelText)}')`;
+      if (labelText) return `getByLabel(${quoteJs(labelText)})`;
     }
     const ariaLabel = el.getAttribute && el.getAttribute("aria-label");
-    if (ariaLabel) return `getByLabel('${escJs(ariaLabel)}')`;
+    if (ariaLabel) return `getByLabel(${quoteJs(ariaLabel)})`;
     const placeholder = el.getAttribute && el.getAttribute("placeholder");
-    if (placeholder) return `getByPlaceholder('${escJs(placeholder)}')`;
+    if (placeholder) return `getByPlaceholder(${quoteJs(placeholder)})`;
     const alt = el.getAttribute && el.getAttribute("alt");
-    if (alt) return `getByAltText('${escJs(alt)}')`;
+    if (alt) return `getByAltText(${quoteJs(alt)})`;
     const titleAttr = el.getAttribute && el.getAttribute("title");
-    if (titleAttr) return `getByTitle('${escJs(titleAttr)}')`;
-    if (el.id) return `locator('#${escJs(el.id)}')`;
+    if (titleAttr) return `getByTitle(${quoteJs(titleAttr)})`;
+    if (el.id) return `locator(${quoteJs(`#${el.id}`)})`;
     const cls = (el.getAttribute && el.getAttribute("class") || "").split(/\s+/).find((c) => c.length > 1);
-    return cls ? `locator('.${escJs(cls)}')` : tag;
+    return cls ? `locator(${quoteJs(`.${cls}`)})` : tag;
   };
   const buildChain = (raw) => {
     const chain2 = [];
@@ -1198,422 +1198,706 @@ function takePauseState() {
   return typeof state === "string" ? state : null;
 }
 
-// ../core/src/locator-generation.ts
-var TAG_TO_ROLE = {
-  a: "link",
-  button: "button",
-  nav: "navigation",
-  main: "main",
-  article: "article",
-  section: "region",
-  form: "form",
-  img: "img",
-  figure: "figure",
-  figcaption: "caption",
-  blockquote: "blockquote",
-  table: "table",
-  caption: "caption",
-  thead: "rowgroup",
-  tbody: "rowgroup",
-  tfoot: "rowgroup",
-  tr: "row",
-  td: "cell",
-  ul: "list",
-  ol: "list",
-  li: "listitem",
-  dialog: "dialog",
-  output: "status",
-  progress: "progressbar",
-  meter: "meter",
-  textarea: "textbox",
-  h1: "heading",
-  h2: "heading",
-  h3: "heading",
-  h4: "heading",
-  h5: "heading",
-  h6: "heading",
-  details: "group",
-  summary: "button",
-  search: "search"
+// ../core/src/locator-chain.ts
+var LOCATING_METHODS = /* @__PURE__ */ new Set([
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator",
+  "frameLocator"
+]);
+var NARROWING_METHODS = /* @__PURE__ */ new Set([
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "visible",
+  "contentFrame",
+  "owner"
+]);
+var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([...LOCATING_METHODS, ...NARROWING_METHODS]);
+var LocatorParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LocatorParseError";
+  }
 };
-var INPUT_TYPE_TO_ROLE = {
-  button: "button",
-  submit: "button",
-  reset: "button",
-  image: "button",
-  checkbox: "checkbox",
-  radio: "radio",
-  range: "slider",
-  search: "searchbox",
-  number: "spinbutton",
-  text: "textbox",
-  email: "textbox",
-  tel: "textbox",
-  url: "textbox",
-  password: "textbox"
+var SIMPLE_ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0"
 };
-var CAPTURED_ATTRIBUTES = [
-  "id",
-  "class",
-  "name",
-  "data-testid",
-  "placeholder",
-  "alt",
-  "title",
-  "aria-label",
-  "aria-labelledby",
-  "aria-level",
-  "role",
-  "type",
-  "href",
-  "multiple"
-];
-function resolveAriaRole(attrs) {
-  const explicit = attrs.attributes["role"];
-  if (explicit) return explicit;
-  const tag = attrs.tagName;
-  if (!tag) return null;
-  if (tag === "input") {
-    const type = (attrs.attributes["type"] ?? "text").toLowerCase();
-    return INPUT_TYPE_TO_ROLE[type] ?? "textbox";
-  }
-  if (tag === "select") {
-    return attrs.attributes["multiple"] != null ? "listbox" : "combobox";
-  }
-  if (tag === "a") {
-    return attrs.attributes["href"] != null ? "link" : null;
-  }
-  return TAG_TO_ROLE[tag] ?? null;
-}
-function headingLevel(attrs, role) {
-  if (role !== "heading") return null;
-  const tagMatch = attrs.tagName.match(/^h([1-6])$/);
-  if (tagMatch) return Number(tagMatch[1]);
-  const ariaLevel = attrs.attributes["aria-level"];
-  if (ariaLevel && /^\d+$/.test(ariaLevel)) return Number(ariaLevel);
-  return null;
-}
-var attr = (a, key) => a.attributes[key] || null;
-var esc = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-var escCssAttrValue = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-var isCssSafeId = (id) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(id);
-function classifyCssStability(className) {
-  if (/[a-f0-9]{8,}/i.test(className)) return 10;
-  if (/^(?:css|sc|emotion|styled)-/i.test(className)) return 15;
-  if (/^(bg|text|border|shadow|opacity|font|w-|h-|m[tblrxy]?-|p[tblrxy]?-|flex|grid|gap|rounded|absolute|relative|fixed|sticky|block|inline|hidden|overflow|z-|top-|right-|bottom-|left-|inset-|justify-|items-|self-|content-|order-|col-|row-)/.test(
-    className
-  ))
-    return 25;
-  if (/__/.test(className) || /--/.test(className)) return 35;
-  if (/^[a-z]+(-[a-z]+)+$/.test(className)) return 40;
-  if (/^[a-z]+[A-Z][a-zA-Z]+$/.test(className)) return 40;
-  if (className.includes("_")) return 15;
-  if (/^[a-z]+-[a-z0-9]{5,}$/.test(className) && /[0-9]/.test(className)) return 15;
-  return 15;
-}
-function isAutoGenerated(value) {
-  if (/^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(value)) return true;
-  if (/^[a-f0-9]{8,}$/i.test(value)) return true;
-  if (/^[a-z]+-\d{4,}$/.test(value)) return true;
-  if (/^(tab|panel|input|select|option|dialog|modal|popup|tooltip|menu|listbox|combobox|checkbox|radio|textarea|button|field|label|accordion|collapse|step|slider|toggle|switch|dropdown|overlay|portal|layer)-\d+$/i.test(
-    value
-  )) {
-    return true;
+var Parser = class {
+  constructor(src) {
+    this.src = src;
+    this.i = 0;
   }
-  if (/^(emotion-|styled-|css-|sc-)/.test(value)) return true;
-  if (value.startsWith("ng-")) return true;
-  if (/^(radix-|headlessui-|mui-|mantine-|chakra-|reka-|bits-|downshift-|react-aria|el-id-)/i.test(value)) return true;
-  if (/^:r[0-9a-z]+:$/i.test(value) || /^«r[0-9a-z]+»$/i.test(value)) return true;
-  if (/(^|[-_:])v-\d+(-\d+)+$/.test(value) || /(^|[-_:])v-\d+(-\d+)+[-_:]/.test(value)) return true;
-  return false;
-}
-var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "data-qa", "data-qa-id", "data-cy", "data-e2e"]);
-function generateAlternatives(attrs, options = {}) {
-  const alts = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (loc) => {
-    if (!seen.has(loc.locator)) {
-      seen.add(loc.locator);
-      alts.push(loc);
-    }
-  };
-  const { accessibleName } = attrs;
-  const tag = attrs.tagName;
-  const role = options.role !== void 0 ? options.role : resolveAriaRole(attrs);
-  const counts = attrs.selectorCounts;
-  const isUnique = (n) => n == null || n <= 1;
-  const ambiguityPenalty = (n) => n != null && n > 1 ? 45 : 0;
-  const text = attrs.textContent ? attrs.textContent.replace(/\s+/g, " ").trim() : null;
-  const testIdAttribute = options.testIdAttribute || "data-testid";
-  const selectable = (name2) => name2.toLowerCase() !== testIdAttribute.toLowerCase();
-  const testId = attr(attrs, testIdAttribute);
-  if (testId && isUnique(counts?.testId)) {
-    add({
-      locator: `getByTestId('${esc(testId)}')`,
-      method: "getByTestId",
-      args: { testId },
-      score: 100
-    });
+  parseTopLevel() {
+    const chain = this.parseChain();
+    this.skipSpace();
+    if (this.i < this.src.length) this.fail("unexpected text");
+    return chain;
   }
-  const level = headingLevel(attrs, role);
-  const levelPart = level != null ? `, level: ${level}` : "";
-  const withLevel = (base) => level != null ? { ...base, level } : base;
-  if (role && accessibleName) {
-    add({
-      locator: `getByRole('${role}', { name: '${esc(accessibleName)}'${levelPart} })`,
-      method: "getByRole",
-      args: withLevel({ role, name: accessibleName }),
-      score: 90 - ambiguityPenalty(counts?.roleName)
-    });
+  fail(message) {
+    throw new LocatorParseError(`${message} at "${this.src.slice(this.i, this.i + 20)}"`);
   }
-  const ariaLabel = attr(attrs, "aria-label");
-  if (role && ariaLabel && ariaLabel !== accessibleName) {
-    add({
-      locator: `getByRole('${role}', { name: '${esc(ariaLabel)}'${levelPart} })`,
-      method: "getByRole",
-      args: withLevel({ role, name: ariaLabel }),
-      score: 85 - ambiguityPenalty(counts?.roleName)
-    });
+  skipSpace() {
+    while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i++;
   }
-  if (accessibleName && ["input", "select", "textarea"].includes(tag)) {
-    const label = attr(attrs, "aria-label");
-    const labelBacked = attrs.hasLabel === void 0 ? true : attrs.hasLabel === true || label === accessibleName;
-    if (labelBacked) {
-      add({
-        locator: `getByLabel('${esc(accessibleName)}')`,
-        method: "getByLabel",
-        args: { label: accessibleName },
-        score: 85
-      });
-    }
+  peek() {
+    return this.src[this.i];
   }
-  const placeholder = attr(attrs, "placeholder");
-  if (placeholder) {
-    add({
-      locator: `getByPlaceholder('${esc(placeholder)}')`,
-      method: "getByPlaceholder",
-      args: { placeholder },
-      score: 80 - ambiguityPenalty(counts?.placeholder)
-    });
+  expect(ch) {
+    this.skipSpace();
+    if (this.src[this.i] !== ch) this.fail(`expected "${ch}"`);
+    this.i++;
   }
-  if (text && text.length < 80) {
-    add({
-      locator: `getByText('${esc(text)}')`,
-      method: "getByText",
-      args: { text },
-      score: 75 - ambiguityPenalty(counts?.text)
-    });
+  identifier() {
+    const m = /^[A-Za-z_$][\w$]*/.exec(this.src.slice(this.i));
+    if (!m) this.fail("expected a name");
+    this.i += m[0].length;
+    return m[0];
   }
-  const id = attr(attrs, "id");
-  if (id && selectable("id") && !isAutoGenerated(id) && isUnique(counts?.id)) {
-    const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
-    add({
-      locator: `locator('${esc(selector)}')`,
-      method: "locator",
-      args: { selector },
-      score: 65
-    });
+  /**
+   * A chain of calls joined by `.`. With `lenient`, parsing stops before the
+   * first link that doesn't parse instead of failing, so a chain followed by
+   * other text (an error message) is read up to where it ends. `spans` receives
+   * where each top-level call starts and ends.
+   */
+  parseChain(opts = {}) {
+    this.skipSpace();
+    const calls = [];
+    for (; ; ) {
+      const before = this.i;
+      if (calls.length > 0) this.i++;
+      this.skipSpace();
+      const start = this.i;
+      try {
+        calls.push(this.parseCall(calls.length === 0));
+      } catch (error) {
+        if (!opts.lenient || calls.length === 0) throw error;
+        this.i = before;
+        break;
+      }
+      opts.spans?.push({ start, end: this.i });
+      const end = this.i;
+      this.skipSpace();
+      if (this.peek() !== ".") {
+        this.i = end;
+        break;
+      }
+    }
+    return { calls };
   }
-  const name = attr(attrs, "name");
-  if (name && selectable("name") && isUnique(counts?.name)) {
-    const selector = `[name="${escCssAttrValue(name)}"]`;
-    add({
-      locator: `locator('${esc(selector)}')`,
-      method: "locator",
-      args: { selector },
-      score: 60
-    });
+  /** Where the parser stopped. */
+  get position() {
+    return this.i;
   }
-  const alt = attr(attrs, "alt");
-  if (alt) {
-    add({
-      locator: `getByAltText('${esc(alt)}')`,
-      method: "getByAltText",
-      args: { text: alt },
-      score: 60 - ambiguityPenalty(counts?.alt)
-    });
+  parseCall(first) {
+    this.skipSpace();
+    const method = this.identifier();
+    if (!LOCATOR_CHAIN_METHODS.has(method)) this.fail(`unsupported method ${method}()`);
+    if (first && !LOCATING_METHODS.has(method)) this.fail(`${method}() needs a locator before it`);
+    this.expect("(");
+    const args = [];
+    this.skipSpace();
+    if (this.peek() === ")") {
+      this.i++;
+      return { method, args };
+    }
+    for (; ; ) {
+      args.push(this.parseValue());
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        this.skipSpace();
+        if (this.peek() === ")") {
+          this.i++;
+          break;
+        }
+        continue;
+      }
+      this.expect(")");
+      break;
+    }
+    return { method, args };
   }
-  const title = attr(attrs, "title");
-  if (title) {
-    add({
-      locator: `getByTitle('${esc(title)}')`,
-      method: "getByTitle",
-      args: { title },
-      score: 50 - ambiguityPenalty(counts?.title)
-    });
+  parseValue() {
+    this.skipSpace();
+    const ch = this.peek();
+    if (ch === "'" || ch === '"' || ch === "`") return { type: "string", value: this.parseString() };
+    if (ch === "/") return this.parseRegex();
+    if (ch === "{") return this.parseObject();
+    if (ch !== void 0 && /[-\d]/.test(ch)) {
+      const m = /^-?\d+(?:\.\d+)?/.exec(this.src.slice(this.i));
+      if (!m) this.fail("expected a number");
+      this.i += m[0].length;
+      return { type: "number", value: Number(m[0]) };
+    }
+    const rest = this.src.slice(this.i);
+    if (/^true\b/.test(rest)) {
+      this.i += 4;
+      return { type: "boolean", value: true };
+    }
+    if (/^false\b/.test(rest)) {
+      this.i += 5;
+      return { type: "boolean", value: false };
+    }
+    if (/^[A-Za-z_$]/.test(rest)) return { type: "chain", chain: this.parseChain() };
+    return this.fail("expected a value");
   }
-  const hasOwnTestId = !!(testId && isUnique(counts?.testId));
-  const addAnchoredChains = (leaf, scopedCount, scores) => {
-    let testIdAnchorDone = false;
-    let idAnchorDone = false;
-    let roleAnchorDone = false;
-    let dataAnchorDone = false;
-    let filterAnchorDone = false;
-    for (const anc of attrs.ancestors ?? []) {
-      if (scopedCount(anc) !== 1) continue;
-      if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
-        testIdAnchorDone = true;
-        add({
-          locator: `getByTestId('${esc(anc.testId)}').${leaf.expr}`,
-          method: leaf.method,
-          args: { ...leaf.args, anchorTestId: anc.testId },
-          score: scores.testId
-        });
-      }
-      if (!idAnchorDone && anc.id && selectable("id") && !isAutoGenerated(anc.id) && anc.idCount === 1) {
-        idAnchorDone = true;
-        const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
-        add({
-          locator: `locator('${esc(anchorSelector)}').${leaf.expr}`,
-          method: leaf.method,
-          args: { ...leaf.args, anchorSelector },
-          score: scores.id
-        });
+  /** A quoted string, decoding the escapes `JSON.stringify` and JavaScript produce. */
+  parseString() {
+    const quote = this.src[this.i];
+    let out = "";
+    this.i++;
+    while (this.i < this.src.length) {
+      const c = this.src[this.i];
+      if (c === quote) {
+        this.i++;
+        return out;
       }
-      if (!dataAnchorDone && anc.dataAttr && selectable(anc.dataAttr.name) && anc.dataAttrCount === 1) {
-        dataAnchorDone = true;
-        const { name: name2, value } = anc.dataAttr;
-        const anchorSelector = `[${name2}="${escCssAttrValue(value)}"]`;
-        add({
-          locator: `locator('${esc(anchorSelector)}').${leaf.expr}`,
-          method: leaf.method,
-          args: { ...leaf.args, anchorSelector },
-          score: TEST_DATA_ATTRS.has(name2) ? scores.testData : scores.data
-        });
+      if (c !== "\\") {
+        out += c;
+        this.i++;
+        continue;
       }
-      const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
-      if (!roleAnchorDone && ancestorRole && ancestorRole !== leaf.role && anc.roleCount === 1) {
-        roleAnchorDone = true;
-        add({
-          locator: `getByRole('${esc(ancestorRole)}').${leaf.expr}`,
-          method: leaf.method,
-          args: { ...leaf.args, anchorRole: ancestorRole },
-          score: scores.role
-        });
+      const next = this.src[this.i + 1];
+      if (next === void 0) break;
+      const simple = SIMPLE_ESCAPES[next];
+      if (simple !== void 0) {
+        out += simple;
+        this.i += 2;
+        continue;
       }
-      if (!filterAnchorDone && ancestorRole && anc.filterText && anc.filterRoleCount === 1) {
-        filterAnchorDone = true;
-        add({
-          locator: `getByRole('${esc(ancestorRole)}').filter({ hasText: '${esc(anc.filterText)}' }).${leaf.expr}`,
-          method: leaf.method,
-          args: { ...leaf.args, anchorRole: ancestorRole, anchorHasText: anc.filterText },
-          score: scores.filter
-        });
+      const hex = next === "u" && this.src[this.i + 2] === "{" ? /^u\{([0-9a-fA-F]{1,6})\}/.exec(this.src.slice(this.i + 1)) : next === "u" ? /^u([0-9a-fA-F]{4})/.exec(this.src.slice(this.i + 1)) : next === "x" ? /^x([0-9a-fA-F]{2})/.exec(this.src.slice(this.i + 1)) : null;
+      if (hex) {
+        out += String.fromCodePoint(parseInt(hex[1], 16));
+        this.i += 1 + hex[0].length;
+        continue;
       }
+      if (next === "u" || next === "x") this.fail("malformed escape");
+      out += next;
+      this.i += 2;
     }
-  };
-  if (role && !hasOwnTestId) {
-    const rolePart = level != null ? `'${role}', { level: ${level} }` : `'${role}'`;
-    const leafArgs = withLevel({ role });
-    addAnchoredChains(
-      { expr: `getByRole(${rolePart})`, method: "getByRole", args: leafArgs, role },
-      (anc) => anc.scopedRoleCount,
-      { testId: 72, testData: 70, id: 64, data: 60, role: 55, filter: 53 }
-    );
-    const pos = attrs.rolePosition;
-    if (pos && pos.role === role && (pos.count === 1 || level != null && pos.levelCount === 1)) {
-      add({
-        locator: `getByRole(${rolePart})`,
-        method: "getByRole",
-        args: leafArgs,
-        score: 58
-      });
-    }
-  } else if (!role && text && text.length < 80 && !hasOwnTestId) {
-    addAnchoredChains(
-      { expr: `getByText('${esc(text)}')`, method: "getByText", args: { text }, role: null },
-      (anc) => anc.scopedTextCount,
-      { testId: 68, testData: 66, id: 60, data: 56, role: 51, filter: 49 }
-    );
+    return this.fail("unterminated string");
   }
-  const clsStr = attr(attrs, "class");
-  if (clsStr) {
-    const countsClasses = counts?.classes;
-    const classes = clsStr.split(/\s+/).filter((c) => c.length > 1 && /^[A-Za-z_-][A-Za-z0-9_-]*$/.test(c) && isUnique(countsClasses?.[c])).map((cls) => ({ cls, score: classifyCssStability(cls) })).sort((a, b) => b.score - a.score).slice(0, 3);
-    for (const { cls, score } of classes) {
-      add({
-        locator: `locator('.${esc(cls)}')`,
-        method: "locator",
-        args: { selector: `.${cls}` },
-        score
-      });
+  parseRegex() {
+    let j = this.i + 1;
+    let inClass = false;
+    while (j < this.src.length) {
+      const c = this.src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "[") inClass = true;
+      else if (c === "]") inClass = false;
+      else if (c === "/" && !inClass) break;
+      j++;
     }
+    if (j >= this.src.length) this.fail("unterminated regex");
+    const source = this.src.slice(this.i + 1, j);
+    const flags = /^[a-z]*/.exec(this.src.slice(j + 1))[0];
+    this.i = j + 1 + flags.length;
+    return { type: "regex", source, flags };
+  }
+  parseObject() {
+    this.expect("{");
+    const entries = [];
+    for (; ; ) {
+      this.skipSpace();
+      if (this.peek() === "}") {
+        this.i++;
+        break;
+      }
+      const ch = this.peek();
+      const key = ch === "'" || ch === '"' ? this.parseString() : this.identifier();
+      this.expect(":");
+      entries.push([key, this.parseValue()]);
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        continue;
+      }
+      this.expect("}");
+      break;
+    }
+    return { type: "object", entries };
+  }
+};
+function parseLocatorChain(expr) {
+  const trimmed = expr.trim().replace(/^(?:await\s+)?(?:this\.)?page\./, "");
+  if (!trimmed) throw new LocatorParseError("empty expression");
+  return new Parser(trimmed).parseTopLevel();
+}
+function tryParseLocatorChain(expr) {
+  try {
+    return parseLocatorChain(expr);
+  } catch {
+    return null;
+  }
+}
+function quoteJsString(value) {
+  const json = JSON.stringify(value).slice(1, -1);
+  return `'${json.replace(/\\"/g, '"').replace(/'/g, "\\'").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}'`;
+}
+function parseLeafLocatorCall(expr) {
+  const chain = tryParseLocatorChain(expr);
+  if (!chain) return null;
+  for (let i = chain.calls.length - 1; i >= 0; i--) {
+    if (LOCATING_METHODS.has(chain.calls[i].method)) return chain.calls[i];
   }
-  return alts.sort((a, b) => b.score - a.score);
-}
-function approximateAccessibleName(attrs) {
-  const a = attrs.attributes;
-  const labelText = attrs.labelText || null;
-  if (a["aria-labelledby"] && labelText) return labelText;
-  const ariaLabel = a["aria-label"];
-  if (ariaLabel) return ariaLabel;
-  if (["input", "select", "textarea"].includes(attrs.tagName)) {
-    if (labelText) return labelText;
-  } else if (attrs.textContent) {
-    return attrs.textContent;
-  }
-  const title = a["title"];
-  if (title) return title;
-  const placeholder = a["placeholder"];
-  if (placeholder) return placeholder;
   return null;
 }
+function locatorCallValues(call, opts = {}) {
+  const value = (arg) => {
+    switch (arg.type) {
+      case "string":
+      case "number":
+      case "boolean":
+        return arg.value;
+      case "regex":
+        return opts.regexAsText ? `/${arg.source}/${arg.flags}` : void 0;
+      case "object": {
+        const out = {};
+        for (const [key, v] of arg.entries) {
+          const plain = value(v);
+          if (plain !== void 0) out[key] = plain;
+        }
+        return out;
+      }
+      case "chain":
+        return void 0;
+    }
+  };
+  return call.args.map(value).filter((v) => v !== void 0);
+}
 
-// ../picker-dom/src/anchor-alternatives.ts
-var escStr = (s) => s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
-var cssIdSelector = (id) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(id) ? `#${id}` : `[id="${id.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"]`;
-var ANCHOR_KIND_SCORES = { testid: 80, id: 74, labeledRole: 68, role: 62 };
-function anchorSegment(a) {
-  if (a.testId && a.testIdCount === 1) {
-    return { code: `getByTestId('${escStr(a.testId)}')`, kind: "testid", flatArgs: { anchorTestId: a.testId } };
-  }
-  if (a.id && !isAutoGenerated(a.id) && a.idCount === 1) {
-    const anchorSelector = cssIdSelector(a.id);
-    return { code: `locator('${escStr(anchorSelector)}')`, kind: "id", flatArgs: { anchorSelector } };
+// ../core/src/locator-generation.ts
+var TAG_TO_ROLE = {
+  a: "link",
+  button: "button",
+  nav: "navigation",
+  main: "main",
+  article: "article",
+  section: "region",
+  form: "form",
+  img: "img",
+  figure: "figure",
+  figcaption: "caption",
+  blockquote: "blockquote",
+  table: "table",
+  caption: "caption",
+  thead: "rowgroup",
+  tbody: "rowgroup",
+  tfoot: "rowgroup",
+  tr: "row",
+  td: "cell",
+  ul: "list",
+  ol: "list",
+  li: "listitem",
+  dialog: "dialog",
+  output: "status",
+  progress: "progressbar",
+  meter: "meter",
+  textarea: "textbox",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  details: "group",
+  summary: "button",
+  search: "search"
+};
+var INPUT_TYPE_TO_ROLE = {
+  button: "button",
+  submit: "button",
+  reset: "button",
+  image: "button",
+  checkbox: "checkbox",
+  radio: "radio",
+  range: "slider",
+  search: "searchbox",
+  number: "spinbutton",
+  text: "textbox",
+  email: "textbox",
+  tel: "textbox",
+  url: "textbox",
+  password: "textbox"
+};
+var CAPTURED_ATTRIBUTES = [
+  "id",
+  "class",
+  "name",
+  "data-testid",
+  "placeholder",
+  "alt",
+  "title",
+  "aria-label",
+  "aria-labelledby",
+  "aria-level",
+  "role",
+  "type",
+  "href",
+  "multiple"
+];
+function resolveAriaRole(attrs) {
+  const explicit = attrs.attributes["role"];
+  if (explicit) return explicit;
+  const tag = attrs.tagName;
+  if (!tag) return null;
+  if (tag === "input") {
+    const type = (attrs.attributes["type"] ?? "text").toLowerCase();
+    return INPUT_TYPE_TO_ROLE[type] ?? "textbox";
   }
-  if (a.role && a.ariaLabel && a.labeledRoleCount === 1) {
-    return {
-      code: `getByRole('${escStr(a.role)}', { name: '${escStr(a.ariaLabel)}' })`,
-      kind: "labeledRole",
-      flatArgs: { anchorRole: a.role, anchorName: a.ariaLabel }
-    };
+  if (tag === "select") {
+    return attrs.attributes["multiple"] != null ? "listbox" : "combobox";
   }
-  if (a.role && a.roleCount === 1) {
-    return { code: `getByRole('${escStr(a.role)}')`, kind: "role", flatArgs: { anchorRole: a.role } };
+  if (tag === "a") {
+    return attrs.attributes["href"] != null ? "link" : null;
   }
+  return TAG_TO_ROLE[tag] ?? null;
+}
+function headingLevel(attrs, role) {
+  if (role !== "heading") return null;
+  const tagMatch = attrs.tagName.match(/^h([1-6])$/);
+  if (tagMatch) return Number(tagMatch[1]);
+  const ariaLevel = attrs.attributes["aria-level"];
+  if (ariaLevel && /^\d+$/.test(ariaLevel)) return Number(ariaLevel);
   return null;
 }
-function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
-  if (!leaf.role || anchors.length === 0) return [];
-  const out = [];
+var attr = (a, key) => a.attributes[key] || null;
+var escCssAttrValue = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+var isCssSafeId = (id) => /^[A-Za-z][A-Za-z0-9_-]*$/.test(id);
+function classifyCssStability(className) {
+  if (/[a-f0-9]{8,}/i.test(className)) return 10;
+  if (/^(?:css|sc|emotion|styled)-/i.test(className)) return 15;
+  if (/^(bg|text|border|shadow|opacity|font|w-|h-|m[tblrxy]?-|p[tblrxy]?-|flex|grid|gap|rounded|absolute|relative|fixed|sticky|block|inline|hidden|overflow|z-|top-|right-|bottom-|left-|inset-|justify-|items-|self-|content-|order-|col-|row-)/.test(
+    className
+  ))
+    return 25;
+  if (/__/.test(className) || /--/.test(className)) return 35;
+  if (/^[a-z]+(-[a-z]+)+$/.test(className)) return 40;
+  if (/^[a-z]+[A-Z][a-zA-Z]+$/.test(className)) return 40;
+  if (className.includes("_")) return 15;
+  if (/^[a-z]+-[a-z0-9]{5,}$/.test(className) && /[0-9]/.test(className)) return 15;
+  return 15;
+}
+function isAutoGenerated(value) {
+  if (/^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(value)) return true;
+  if (/^[a-f0-9]{8,}$/i.test(value)) return true;
+  if (/^[a-z]+-\d{4,}$/.test(value)) return true;
+  if (/^(tab|panel|input|select|option|dialog|modal|popup|tooltip|menu|listbox|combobox|checkbox|radio|textarea|button|field|label|accordion|collapse|step|slider|toggle|switch|dropdown|overlay|portal|layer)-\d+$/i.test(
+    value
+  )) {
+    return true;
+  }
+  if (/^(emotion-|styled-|css-|sc-)/.test(value)) return true;
+  if (value.startsWith("ng-")) return true;
+  if (/^(radix-|headlessui-|mui-|mantine-|chakra-|reka-|bits-|downshift-|react-aria|el-id-)/i.test(value)) return true;
+  if (/^:r[0-9a-z]+:$/i.test(value) || /^«r[0-9a-z]+»$/i.test(value)) return true;
+  if (/(^|[-_:])v-\d+(-\d+)+$/.test(value) || /(^|[-_:])v-\d+(-\d+)+[-_:]/.test(value)) return true;
+  return false;
+}
+var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "data-qa", "data-qa-id", "data-cy", "data-e2e"]);
+function generateAlternatives(attrs, options = {}) {
+  const alts = [];
   const seen = /* @__PURE__ */ new Set();
-  const rolePart = leaf.level != null ? `'${leaf.role}', { level: ${leaf.level} }` : `'${leaf.role}'`;
-  const leafArgs = leaf.level != null ? { role: leaf.role, level: leaf.level } : { role: leaf.role };
-  const add = (l) => {
-    if (!seen.has(l.locator)) {
-      seen.add(l.locator);
-      out.push(l);
+  const add = (loc) => {
+    if (!seen.has(loc.locator)) {
+      seen.add(loc.locator);
+      alts.push(loc);
     }
   };
-  for (const anchor of anchors) {
-    if (anchor.scopedLeafCount !== 1) continue;
-    const seg = anchorSegment(anchor);
-    if (!seg) continue;
+  const { accessibleName } = attrs;
+  const tag = attrs.tagName;
+  const role = options.role !== void 0 ? options.role : resolveAriaRole(attrs);
+  const counts = attrs.selectorCounts;
+  const isUnique = (n) => n == null || n <= 1;
+  const ambiguityPenalty = (n) => n != null && n > 1 ? 45 : 0;
+  const text = attrs.textContent ? attrs.textContent.replace(/\s+/g, " ").trim() : null;
+  const testIdAttribute = options.testIdAttribute || "data-testid";
+  const selectable = (name2) => name2.toLowerCase() !== testIdAttribute.toLowerCase();
+  const testId = attr(attrs, testIdAttribute);
+  if (testId && isUnique(counts?.testId)) {
     add({
-      locator: `${seg.code}.getByRole(${rolePart})`,
+      locator: `getByTestId(${quoteJsString(testId)})`,
+      method: "getByTestId",
+      args: { testId },
+      score: 100
+    });
+  }
+  const level = headingLevel(attrs, role);
+  const levelPart = level != null ? `, level: ${level}` : "";
+  const withLevel = (base) => level != null ? { ...base, level } : base;
+  if (role && accessibleName) {
+    add({
+      locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(accessibleName)}${levelPart} })`,
       method: "getByRole",
-      args: { ...leafArgs, ...seg.flatArgs },
-      score: ANCHOR_KIND_SCORES[seg.kind]
+      args: withLevel({ role, name: accessibleName }),
+      score: 90 - ambiguityPenalty(counts?.roleName)
     });
   }
-  if (anchors.length >= 2 && chainLeafCount === 1) {
-    const ordered = [...anchors].sort((a, b) => b.depth - a.depth);
-    const segments = ordered.map(anchorSegment);
-    if (segments.every((s) => s !== null)) {
-      const innermost = segments[segments.length - 1];
-      const score = Math.min(...segments.map((s) => ANCHOR_KIND_SCORES[s.kind]));
-      add({
-        locator: `${segments.map((s) => s.code).join(".")}.getByRole(${rolePart})`,
+  const ariaLabel = attr(attrs, "aria-label");
+  if (role && ariaLabel && ariaLabel !== accessibleName) {
+    add({
+      locator: `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(ariaLabel)}${levelPart} })`,
+      method: "getByRole",
+      args: withLevel({ role, name: ariaLabel }),
+      score: 85 - ambiguityPenalty(counts?.roleName)
+    });
+  }
+  if (accessibleName && ["input", "select", "textarea"].includes(tag)) {
+    const label = attr(attrs, "aria-label");
+    const labelBacked = attrs.hasLabel === void 0 ? true : attrs.hasLabel === true || label === accessibleName;
+    if (labelBacked) {
+      add({
+        locator: `getByLabel(${quoteJsString(accessibleName)})`,
+        method: "getByLabel",
+        args: { label: accessibleName },
+        score: 85
+      });
+    }
+  }
+  const placeholder = attr(attrs, "placeholder");
+  if (placeholder) {
+    add({
+      locator: `getByPlaceholder(${quoteJsString(placeholder)})`,
+      method: "getByPlaceholder",
+      args: { placeholder },
+      score: 80 - ambiguityPenalty(counts?.placeholder)
+    });
+  }
+  if (text && text.length < 80) {
+    add({
+      locator: `getByText(${quoteJsString(text)})`,
+      method: "getByText",
+      args: { text },
+      score: 75 - ambiguityPenalty(counts?.text)
+    });
+  }
+  const id = attr(attrs, "id");
+  if (id && selectable("id") && !isAutoGenerated(id) && isUnique(counts?.id)) {
+    const selector = isCssSafeId(id) ? `#${id}` : `[id="${escCssAttrValue(id)}"]`;
+    add({
+      locator: `locator(${quoteJsString(selector)})`,
+      method: "locator",
+      args: { selector },
+      score: 65
+    });
+  }
+  const name = attr(attrs, "name");
+  if (name && selectable("name") && isUnique(counts?.name)) {
+    const selector = `[name="${escCssAttrValue(name)}"]`;
+    add({
+      locator: `locator(${quoteJsString(selector)})`,
+      method: "locator",
+      args: { selector },
+      score: 60
+    });
+  }
+  const alt = attr(attrs, "alt");
+  if (alt) {
+    add({
+      locator: `getByAltText(${quoteJsString(alt)})`,
+      method: "getByAltText",
+      args: { text: alt },
+      score: 60 - ambiguityPenalty(counts?.alt)
+    });
+  }
+  const title = attr(attrs, "title");
+  if (title) {
+    add({
+      locator: `getByTitle(${quoteJsString(title)})`,
+      method: "getByTitle",
+      args: { title },
+      score: 50 - ambiguityPenalty(counts?.title)
+    });
+  }
+  const hasOwnTestId = !!(testId && isUnique(counts?.testId));
+  const addAnchoredChains = (leaf, scopedCount, scores) => {
+    let testIdAnchorDone = false;
+    let idAnchorDone = false;
+    let roleAnchorDone = false;
+    let dataAnchorDone = false;
+    let filterAnchorDone = false;
+    for (const anc of attrs.ancestors ?? []) {
+      if (scopedCount(anc) !== 1) continue;
+      if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
+        testIdAnchorDone = true;
+        add({
+          locator: `getByTestId(${quoteJsString(anc.testId)}).${leaf.expr}`,
+          method: leaf.method,
+          args: { ...leaf.args, anchorTestId: anc.testId },
+          score: scores.testId
+        });
+      }
+      if (!idAnchorDone && anc.id && selectable("id") && !isAutoGenerated(anc.id) && anc.idCount === 1) {
+        idAnchorDone = true;
+        const anchorSelector = isCssSafeId(anc.id) ? `#${anc.id}` : `[id="${escCssAttrValue(anc.id)}"]`;
+        add({
+          locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
+          method: leaf.method,
+          args: { ...leaf.args, anchorSelector },
+          score: scores.id
+        });
+      }
+      if (!dataAnchorDone && anc.dataAttr && selectable(anc.dataAttr.name) && anc.dataAttrCount === 1) {
+        dataAnchorDone = true;
+        const { name: name2, value } = anc.dataAttr;
+        const anchorSelector = `[${name2}="${escCssAttrValue(value)}"]`;
+        add({
+          locator: `locator(${quoteJsString(anchorSelector)}).${leaf.expr}`,
+          method: leaf.method,
+          args: { ...leaf.args, anchorSelector },
+          score: TEST_DATA_ATTRS.has(name2) ? scores.testData : scores.data
+        });
+      }
+      const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
+      if (!roleAnchorDone && ancestorRole && ancestorRole !== leaf.role && anc.roleCount === 1) {
+        roleAnchorDone = true;
+        add({
+          locator: `getByRole(${quoteJsString(ancestorRole)}).${leaf.expr}`,
+          method: leaf.method,
+          args: { ...leaf.args, anchorRole: ancestorRole },
+          score: scores.role
+        });
+      }
+      if (!filterAnchorDone && ancestorRole && anc.filterText && anc.filterRoleCount === 1) {
+        filterAnchorDone = true;
+        add({
+          locator: `getByRole(${quoteJsString(ancestorRole)}).filter({ hasText: ${quoteJsString(anc.filterText)} }).${leaf.expr}`,
+          method: leaf.method,
+          args: { ...leaf.args, anchorRole: ancestorRole, anchorHasText: anc.filterText },
+          score: scores.filter
+        });
+      }
+    }
+  };
+  if (role && !hasOwnTestId) {
+    const rolePart = level != null ? `${quoteJsString(role)}, { level: ${level} }` : quoteJsString(role);
+    const leafArgs = withLevel({ role });
+    addAnchoredChains(
+      { expr: `getByRole(${rolePart})`, method: "getByRole", args: leafArgs, role },
+      (anc) => anc.scopedRoleCount,
+      { testId: 72, testData: 70, id: 64, data: 60, role: 55, filter: 53 }
+    );
+    const pos = attrs.rolePosition;
+    if (pos && pos.role === role && (pos.count === 1 || level != null && pos.levelCount === 1)) {
+      add({
+        locator: `getByRole(${rolePart})`,
+        method: "getByRole",
+        args: leafArgs,
+        score: 58
+      });
+    }
+  } else if (!role && text && text.length < 80 && !hasOwnTestId) {
+    addAnchoredChains(
+      { expr: `getByText(${quoteJsString(text)})`, method: "getByText", args: { text }, role: null },
+      (anc) => anc.scopedTextCount,
+      { testId: 68, testData: 66, id: 60, data: 56, role: 51, filter: 49 }
+    );
+  }
+  const clsStr = attr(attrs, "class");
+  if (clsStr) {
+    const countsClasses = counts?.classes;
+    const classes = clsStr.split(/\s+/).filter((c) => c.length > 1 && /^[A-Za-z_-][A-Za-z0-9_-]*$/.test(c) && isUnique(countsClasses?.[c])).map((cls) => ({ cls, score: classifyCssStability(cls) })).sort((a, b) => b.score - a.score).slice(0, 3);
+    for (const { cls, score } of classes) {
+      add({
+        locator: `locator(${quoteJsString(`.${cls}`)})`,
+        method: "locator",
+        args: { selector: `.${cls}` },
+        score
+      });
+    }
+  }
+  return alts.sort((a, b) => b.score - a.score);
+}
+function approximateAccessibleName(attrs) {
+  const a = attrs.attributes;
+  const labelText = attrs.labelText || null;
+  if (a["aria-labelledby"] && labelText) return labelText;
+  const ariaLabel = a["aria-label"];
+  if (ariaLabel) return ariaLabel;
+  if (["input", "select", "textarea"].includes(attrs.tagName)) {
+    if (labelText) return labelText;
+  } else if (attrs.textContent) {
+    return attrs.textContent;
+  }
+  const title = a["title"];
+  if (title) return title;
+  const placeholder = a["placeholder"];
+  if (placeholder) return placeholder;
+  return null;
+}
+
+// ../picker-dom/src/anchor-alternatives.ts
+var cssIdSelector = (id) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(id) ? `#${id}` : `[id="${id.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"]`;
+var ANCHOR_KIND_SCORES = { testid: 80, id: 74, labeledRole: 68, role: 62 };
+function anchorSegment(a) {
+  if (a.testId && a.testIdCount === 1) {
+    return { code: `getByTestId(${quoteJsString(a.testId)})`, kind: "testid", flatArgs: { anchorTestId: a.testId } };
+  }
+  if (a.id && !isAutoGenerated(a.id) && a.idCount === 1) {
+    const anchorSelector = cssIdSelector(a.id);
+    return { code: `locator(${quoteJsString(anchorSelector)})`, kind: "id", flatArgs: { anchorSelector } };
+  }
+  if (a.role && a.ariaLabel && a.labeledRoleCount === 1) {
+    return {
+      code: `getByRole(${quoteJsString(a.role)}, { name: ${quoteJsString(a.ariaLabel)} })`,
+      kind: "labeledRole",
+      flatArgs: { anchorRole: a.role, anchorName: a.ariaLabel }
+    };
+  }
+  if (a.role && a.roleCount === 1) {
+    return { code: `getByRole(${quoteJsString(a.role)})`, kind: "role", flatArgs: { anchorRole: a.role } };
+  }
+  return null;
+}
+function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
+  if (!leaf.role || anchors.length === 0) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rolePart = leaf.level != null ? `${quoteJsString(leaf.role)}, { level: ${leaf.level} }` : quoteJsString(leaf.role);
+  const leafArgs = leaf.level != null ? { role: leaf.role, level: leaf.level } : { role: leaf.role };
+  const add = (l) => {
+    if (!seen.has(l.locator)) {
+      seen.add(l.locator);
+      out.push(l);
+    }
+  };
+  for (const anchor of anchors) {
+    if (anchor.scopedLeafCount !== 1) continue;
+    const seg = anchorSegment(anchor);
+    if (!seg) continue;
+    add({
+      locator: `${seg.code}.getByRole(${rolePart})`,
+      method: "getByRole",
+      args: { ...leafArgs, ...seg.flatArgs },
+      score: ANCHOR_KIND_SCORES[seg.kind]
+    });
+  }
+  if (anchors.length >= 2 && chainLeafCount === 1) {
+    const ordered = [...anchors].sort((a, b) => b.depth - a.depth);
+    const segments = ordered.map(anchorSegment);
+    if (segments.every((s) => s !== null)) {
+      const innermost = segments[segments.length - 1];
+      const score = Math.min(...segments.map((s) => ANCHOR_KIND_SCORES[s.kind]));
+      add({
+        locator: `${segments.map((s) => s.code).join(".")}.getByRole(${rolePart})`,
         method: "getByRole",
         // Flat args describe the innermost anchor (what the healing fingerprint
         // logic understands); the full chain rides along for transparency.
@@ -1642,21 +1926,21 @@ var MAX_INDETERMINATE = 20;
 var STEP = String.raw`[a-zA-Z][\w.-]*:[1-9]\d*`;
 var LEVEL = `${STEP}(?:/${STEP})*`;
 var ELEMENT_PATH_RE = new RegExp(`^${LEVEL}(?:\\|${LEVEL})*$`);
-function isElementPath(path14) {
-  return typeof path14 === "string" && path14.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path14);
+function isElementPath(path13) {
+  return typeof path13 === "string" && path13.length <= ELEMENT_PATH_MAX_CHARS && ELEMENT_PATH_RE.test(path13);
 }
 var offsetOf = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 1e7 ? v : null;
 function elementRef(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path14, label } = v;
-  if (!isElementPath(path14)) return null;
-  return { path: path14, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
+  const { path: path13, label } = v;
+  if (!isElementPath(path13)) return null;
+  return { path: path13, label: typeof label === "string" ? label.slice(0, ELEMENT_LABEL_MAX_CHARS) : "" };
 }
 function textPoint(v) {
   if (!v || typeof v !== "object") return null;
-  const { path: path14, offset } = v;
+  const { path: path13, offset } = v;
   const at = offsetOf(offset);
-  return isElementPath(path14) && at !== null ? { path: path14, offset: at } : null;
+  return isElementPath(path13) && at !== null ? { path: path13, offset: at } : null;
 }
 function sanitizePageInteraction(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -1719,6 +2003,23 @@ function textSimilarity(a, b) {
   for (const t of sa) if (sb.has(t)) common++;
   return 2 * common / (sa.size + sb.size);
 }
+var FUNCTION_WORDS = new Set(
+  "the and for with from your you our this that les des une pour avec par sur aux dans vos votre nos notre".split(" ")
+);
+function significantWords(text) {
+  const all = (text ?? "").replace(new RegExp("(\\p{Ll})(\\p{Lu})", "gu"), "$1 $2").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  const meaningful = all.filter((w) => w.length >= 3 && !FUNCTION_WORDS.has(w));
+  return new Set(meaningful.length > 0 ? meaningful : all);
+}
+function significantWordSimilarity(a, b) {
+  const sa = significantWords(a);
+  const sb = significantWords(b);
+  if (sa.size === 0 && sb.size === 0) return 1;
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let common = 0;
+  for (const w of sa) if (sb.has(w)) common++;
+  return 2 * common / (sa.size + sb.size);
+}
 function fingerprintPresent(fp, candidates) {
   if (!fp.name) return false;
   return candidates.some(
@@ -1740,7 +2041,7 @@ function matchRenamedElement(fp, candidates) {
   let best = null;
   let bestScore = -1;
   for (const c of pool) {
-    const s = textSimilarity(c.name, fp.name);
+    const s = significantWordSimilarity(c.name, fp.name);
     if (s > bestScore) {
       bestScore = s;
       best = c;
@@ -1903,7 +2204,6 @@ var NAME_BASED_METHODS = /* @__PURE__ */ new Set([
   "getByTitle",
   "getByAltText"
 ]);
-var escAttr = (s) => s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
 var SUGG_TEXT_ROLES = /* @__PURE__ */ new Set([
   "button",
   "link",
@@ -1936,9 +2236,9 @@ function failedNameAndRole(failed) {
 function renderFailing(failed) {
   const { role, name } = failedNameAndRole(failed);
   if (failed.method === "getByRole") {
-    return name ? `getByRole('${escAttr(role ?? "")}', { name: '${escAttr(name)}' })` : `getByRole('${escAttr(role ?? "")}')`;
+    return name ? `getByRole(${quoteJsString(role ?? "")}, { name: ${quoteJsString(name)} })` : `getByRole(${quoteJsString(role ?? "")})`;
   }
-  return `${failed.method}('${escAttr(name ?? "")}')`;
+  return `${failed.method}(${quoteJsString(name ?? "")})`;
 }
 function freshSuggestions(candidate, failedMethod) {
   const out = [];
@@ -1948,9 +2248,9 @@ function freshSuggestions(candidate, failedMethod) {
     if (!out.includes(s)) out.push(s);
   };
   const levelPart = candidate.level != null ? `, level: ${candidate.level}` : "";
-  const roleLoc = `getByRole('${escAttr(role)}', { name: '${escAttr(name)}'${levelPart} })`;
-  const textLoc = `getByText('${escAttr(name)}')`;
-  const labelLoc = `getByLabel('${escAttr(name)}')`;
+  const roleLoc = `getByRole(${quoteJsString(role)}, { name: ${quoteJsString(name)}${levelPart} })`;
+  const textLoc = `getByText(${quoteJsString(name)})`;
+  const labelLoc = `getByLabel(${quoteJsString(name)})`;
   if (failedMethod === "getByText" && SUGG_TEXT_ROLES.has(role)) push(textLoc);
   if (failedMethod === "getByLabel" && SUGG_FIELD_ROLES.has(role)) push(labelLoc);
   push(roleLoc);
@@ -2037,6 +2337,8 @@ var ATTACHMENT_NAMES = {
   pageInventory: "piwi-page-inventory",
   locatorPages: "piwi-locator-pages",
   codeReach: "piwi-code-reach",
+  browserCoverage: "piwi-browser-coverage",
+  browserFunctions: "piwi-browser-functions",
   serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
@@ -2279,7 +2581,6 @@ var LocatorPageLog = class {
 
 // src/internal/probe/mode.ts
 var fs2 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
@@ -2416,6 +2717,17 @@ var ENV_FALLBACK_SPECS = [
   { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
 ];
 
+// src/internal/support/test-paths.ts
+var path3 = __toESM(require("path"));
+function configDirFromConfig(config) {
+  if (config?.configFile) return path3.dirname(config.configFile);
+  if (config?.rootDir) return config.rootDir;
+  return process.cwd();
+}
+function relativeTestPath(file, base) {
+  return path3.relative(base, file).split(path3.sep).join("/");
+}
+
 // src/internal/probe/plan.ts
 function parseRouteKey(routeKey2) {
   const space = routeKey2.indexOf(" ");
@@ -2423,8 +2735,8 @@ function parseRouteKey(routeKey2) {
   return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path14 = pattern.split("?")[0] ?? pattern;
-  const escaped = path14.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path13 = pattern.split("?")[0] ?? pattern;
+  const escaped = path13.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -2447,13 +2759,13 @@ function matchProbeItem(plan, test) {
 function requestMatchesRoute(method, url, routeKey2) {
   const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path14;
+  let path13;
   try {
-    path14 = new URL(url).pathname;
+    path13 = new URL(url).pathname;
   } catch {
-    path14 = url.split("?")[0] ?? url;
+    path13 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path14);
+  return patternToRegex(pattern).test(path13);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -2475,10 +2787,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path14 = process.env[PIWI_PROBE_ENV.plan];
-  if (path14) {
+  const path13 = process.env[PIWI_PROBE_ENV.plan];
+  if (path13) {
     try {
-      planCache = JSON.parse(fs2.readFileSync(path14, "utf8"));
+      planCache = JSON.parse(fs2.readFileSync(path13, "utf8"));
     } catch {
       planCache = null;
     }
@@ -2488,7 +2800,7 @@ function loadPlan() {
 function probeItemForTest(test) {
   const plan = loadPlan();
   if (!plan) return null;
-  const filePath = test.file ? path3.relative(process.cwd(), test.file).split(path3.sep).join("/") : null;
+  const filePath = test.file ? relativeTestPath(test.file, test.base ?? process.cwd()) : null;
   const suitePath = test.titlePath ? test.titlePath.slice(1, -1) : void 0;
   return matchProbeItem(plan, { title: test.title, filePath, suitePath });
 }
@@ -2502,10 +2814,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path14 = process.env[PIWI_PROBE_ENV.results];
-  if (!path14) return;
+  const path13 = process.env[PIWI_PROBE_ENV.results];
+  if (!path13) return;
   try {
-    fs2.appendFileSync(path14, `${JSON.stringify(line)}
+    fs2.appendFileSync(path13, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -2518,519 +2830,236 @@ var import_node_zlib = require("zlib");
 var PROBE_FAULTS = ["status-500", "empty-body", "drop-field", "stale-value", "slow"];
 var SERVER_PROBE_FAULTS = [
   "throw",
-  "status",
-  "delay",
-  "dependency",
-  "data",
-  "extreme",
-  "replay",
-  "auth",
-  "slow-first"
-];
-function isFaultAllowed(level, fault) {
-  const list = level === "server" ? SERVER_PROBE_FAULTS : PROBE_FAULTS;
-  return list.includes(fault);
-}
-var SLOW_FAULT_DELAY_MS = 5e3;
-function faultRouteAction(fault) {
-  return fault === "slow" ? { kind: "delay", ms: SLOW_FAULT_DELAY_MS } : null;
-}
-function dropOneField(body) {
-  let parsed2;
-  try {
-    parsed2 = JSON.parse(body);
-  } catch {
-    return body;
-  }
-  if (Array.isArray(parsed2)) {
-    let key;
-    for (const el of parsed2) {
-      if (el && typeof el === "object" && !Array.isArray(el)) {
-        key ??= Object.keys(el)[0];
-        if (key) delete el[key];
-      }
-    }
-    return JSON.stringify(parsed2);
-  }
-  if (parsed2 && typeof parsed2 === "object") {
-    const obj = parsed2;
-    const key = Object.keys(obj)[0];
-    if (key) delete obj[key];
-    return JSON.stringify(obj);
-  }
-  return body;
-}
-function computeFault(fault, input) {
-  const base = {
-    status: input.status,
-    body: input.body,
-    contentType: input.contentType ?? null,
-    delayMs: 0,
-    changed: false
-  };
-  switch (fault) {
-    case "status-500":
-      return { ...base, status: 500, changed: input.status !== 500 };
-    case "empty-body":
-      return { ...base, body: "", changed: input.body.length > 0 };
-    case "drop-field": {
-      const body = dropOneField(input.body);
-      return { ...base, body, changed: body !== input.body };
-    }
-    case "stale-value": {
-      const body = input.priorBody ?? input.body;
-      return { ...base, body, changed: body !== input.body };
-    }
-    case "slow":
-      return { ...base, delayMs: SLOW_FAULT_DELAY_MS, changed: true };
-    default:
-      return base;
-  }
-}
-
-// src/internal/probe/sign.ts
-var import_node_crypto = require("crypto");
-function signProbeMessage(secret, nonce, ts, specJson) {
-  return (0, import_node_crypto.createHmac)("sha256", secret).update(`${nonce}.${ts}.${specJson}`).digest("hex");
-}
-function buildProbeHeader(secret, spec, now = Date.now()) {
-  const nonce = (0, import_node_crypto.randomBytes)(8).toString("hex");
-  const specJson = JSON.stringify(spec);
-  const sig = signProbeMessage(secret, nonce, now, specJson);
-  return Buffer.from(JSON.stringify({ nonce, ts: now, specJson, sig }), "utf8").toString("base64");
-}
-
-// src/internal/probe/interception.ts
-function parseProbeTrace(traceHeader) {
-  const none = { appliedFault: null, serverError: false };
-  if (!traceHeader) return none;
-  try {
-    const spans = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf8"));
-    if (!Array.isArray(spans)) return none;
-    const root = spans.find((s) => s && typeof s === "object" && !s.parentId);
-    if (!root) return none;
-    const attrs = root.attrs ?? {};
-    const appliedRaw = attrs["piwi.probe.applied"];
-    const status = Number(attrs["http.status_code"]) || 0;
-    return {
-      appliedFault: appliedRaw != null ? String(appliedRaw) : null,
-      serverError: root.status === "error" || status >= 500
-    };
-  } catch {
-    return none;
-  }
-}
-function fulfillHeaders(responseHeaders, contentType) {
-  const headers = { ...responseHeaders };
-  delete headers["content-length"];
-  delete headers["content-encoding"];
-  if (contentType) headers["content-type"] = contentType;
-  return headers;
-}
-function originOf(url) {
-  try {
-    const origin = new URL(url).origin;
-    return origin && origin !== "null" ? origin : null;
-  } catch {
-    return null;
-  }
-}
-var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, Math.max(0, ms)));
-async function performRouteAction(route, action, startedAt) {
-  switch (action.kind) {
-    case "abort":
-      await route.abort("connectionreset");
-      return;
-    case "status":
-      await route.fulfill({ status: action.status, body: "" });
-      return;
-    case "delay": {
-      const response = await route.fetch();
-      await sleep(startedAt + action.ms - Date.now());
-      await route.fulfill({ response });
-      return;
-    }
-  }
-}
-async function installRouteRules(page, rules) {
-  const state = rules.map(() => createProbeState());
-  page.on("framenavigated", (frame) => {
-    if (frame === page.mainFrame()) for (const s of state) markNavigated(s);
-  });
-  await page.route("**/*", async (route) => {
-    const startedAt = Date.now();
-    const request = route.request();
-    for (let i = 0; i < rules.length; i++) {
-      const rule = rules[i];
-      if (rule.done?.() || !rule.matches(request.method(), request.url())) continue;
-      if (!shouldAct(state[i], rule.match)) continue;
-      await rule.handle(route, startedAt);
-      return;
-    }
-    await route.fallback();
-  });
-  return { state };
-}
-async function installProbeInterception(page, item) {
-  if (!isFaultAllowed(item.level ?? "client", item.fault)) {
-    return { applied: () => false, appliedFault: () => null, serverError: () => false };
-  }
-  let applied = false;
-  let appliedFault = null;
-  let serverError = false;
-  let appOrigin = null;
-  const probeSecret = process.env[PIWI_PROBE_ENV.secret];
-  page.on("framenavigated", (frame) => {
-    if (frame === page.mainFrame()) {
-      const origin = originOf(page.url());
-      if (origin) appOrigin = origin;
-    }
-  });
-  const handle = async (route, startedAt) => {
-    const request = route.request();
-    if (item.level === "server") {
-      if (!probeSecret || appOrigin !== null && originOf(request.url()) !== appOrigin) {
-        await route.fallback();
-        return;
-      }
-      const spec = { route: item.routeKey, fault: item.fault, nth: item.nth };
-      if (item.dependency) spec.dependency = item.dependency;
-      try {
-        const response = await route.fetch({
-          headers: { ...request.headers(), "x-piwi-probe": buildProbeHeader(probeSecret, spec) }
-        });
-        const trace = parseProbeTrace(response.headers()["x-piwi-trace"]);
-        appliedFault = trace.appliedFault;
-        serverError = trace.serverError;
-        applied = trace.appliedFault != null && trace.appliedFault.split(":", 1)[0] === item.fault;
-        await route.fulfill({ response });
-      } catch {
-        applied = false;
-        await route.fallback();
-      }
-      return;
-    }
-    try {
-      const action = faultRouteAction(item.fault);
-      if (action) {
-        applied = true;
-        appliedFault = item.fault;
-        await performRouteAction(route, action, startedAt);
-        return;
-      }
-      const response = await route.fetch();
-      const body = await response.text();
-      const out = computeFault(item.fault, {
-        status: response.status(),
-        body,
-        contentType: response.headers()["content-type"] ?? null
-      });
-      applied = out.changed;
-      if (applied) appliedFault = item.fault;
-      const headers = fulfillHeaders(response.headers(), out.contentType);
-      await route.fulfill({ status: out.status, body: out.body, headers });
-    } catch {
-      applied = false;
-      await route.fallback();
-    }
-  };
-  await installRouteRules(page, [
-    {
-      matches: (method, url) => requestMatchesRoute(method, url, item.routeKey),
-      match: Math.max(1, item.nth ?? 1),
-      handle,
-      done: () => applied
-    }
-  ]);
-  return { applied: () => applied, appliedFault: () => appliedFault, serverError: () => serverError };
-}
-
-// src/internal/flake/mode.ts
-var fs3 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-
-// ../core/src/locator-chain.ts
-var LOCATING_METHODS = /* @__PURE__ */ new Set([
-  "getByRole",
-  "getByTestId",
-  "getByText",
-  "getByLabel",
-  "getByPlaceholder",
-  "getByAltText",
-  "getByTitle",
-  "locator",
-  "frameLocator"
-]);
-var NARROWING_METHODS = /* @__PURE__ */ new Set([
-  "filter",
-  "first",
-  "last",
-  "nth",
-  "and",
-  "or",
-  "visible",
-  "contentFrame",
-  "owner"
-]);
-var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([...LOCATING_METHODS, ...NARROWING_METHODS]);
-var LocatorParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LocatorParseError";
-  }
-};
-var SIMPLE_ESCAPES = {
-  n: "\n",
-  t: "	",
-  r: "\r",
-  b: "\b",
-  f: "\f",
-  v: "\v",
-  "0": "\0"
-};
-var Parser = class {
-  constructor(src) {
-    this.src = src;
-    this.i = 0;
-  }
-  parseTopLevel() {
-    const chain = this.parseChain();
-    this.skipSpace();
-    if (this.i < this.src.length) this.fail("unexpected text");
-    return chain;
-  }
-  fail(message) {
-    throw new LocatorParseError(`${message} at "${this.src.slice(this.i, this.i + 20)}"`);
-  }
-  skipSpace() {
-    while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i++;
-  }
-  peek() {
-    return this.src[this.i];
-  }
-  expect(ch) {
-    this.skipSpace();
-    if (this.src[this.i] !== ch) this.fail(`expected "${ch}"`);
-    this.i++;
-  }
-  identifier() {
-    const m = /^[A-Za-z_$][\w$]*/.exec(this.src.slice(this.i));
-    if (!m) this.fail("expected a name");
-    this.i += m[0].length;
-    return m[0];
-  }
-  /**
-   * A chain of calls joined by `.`. With `lenient`, parsing stops before the
-   * first link that doesn't parse instead of failing, so a chain followed by
-   * other text (an error message) is read up to where it ends. `spans` receives
-   * where each top-level call starts and ends.
-   */
-  parseChain(opts = {}) {
-    this.skipSpace();
-    const calls = [];
-    for (; ; ) {
-      const before = this.i;
-      if (calls.length > 0) this.i++;
-      this.skipSpace();
-      const start = this.i;
-      try {
-        calls.push(this.parseCall(calls.length === 0));
-      } catch (error) {
-        if (!opts.lenient || calls.length === 0) throw error;
-        this.i = before;
-        break;
-      }
-      opts.spans?.push({ start, end: this.i });
-      const end = this.i;
-      this.skipSpace();
-      if (this.peek() !== ".") {
-        this.i = end;
-        break;
-      }
-    }
-    return { calls };
-  }
-  /** Where the parser stopped. */
-  get position() {
-    return this.i;
-  }
-  parseCall(first) {
-    this.skipSpace();
-    const method = this.identifier();
-    if (!LOCATOR_CHAIN_METHODS.has(method)) this.fail(`unsupported method ${method}()`);
-    if (first && !LOCATING_METHODS.has(method)) this.fail(`${method}() needs a locator before it`);
-    this.expect("(");
-    const args = [];
-    this.skipSpace();
-    if (this.peek() === ")") {
-      this.i++;
-      return { method, args };
-    }
-    for (; ; ) {
-      args.push(this.parseValue());
-      this.skipSpace();
-      if (this.peek() === ",") {
-        this.i++;
-        this.skipSpace();
-        if (this.peek() === ")") {
-          this.i++;
-          break;
-        }
-        continue;
-      }
-      this.expect(")");
-      break;
-    }
-    return { method, args };
-  }
-  parseValue() {
-    this.skipSpace();
-    const ch = this.peek();
-    if (ch === "'" || ch === '"' || ch === "`") return { type: "string", value: this.parseString() };
-    if (ch === "/") return this.parseRegex();
-    if (ch === "{") return this.parseObject();
-    if (ch !== void 0 && /[-\d]/.test(ch)) {
-      const m = /^-?\d+(?:\.\d+)?/.exec(this.src.slice(this.i));
-      if (!m) this.fail("expected a number");
-      this.i += m[0].length;
-      return { type: "number", value: Number(m[0]) };
-    }
-    const rest = this.src.slice(this.i);
-    if (/^true\b/.test(rest)) {
-      this.i += 4;
-      return { type: "boolean", value: true };
-    }
-    if (/^false\b/.test(rest)) {
-      this.i += 5;
-      return { type: "boolean", value: false };
-    }
-    if (/^[A-Za-z_$]/.test(rest)) return { type: "chain", chain: this.parseChain() };
-    return this.fail("expected a value");
-  }
-  /** A quoted string, decoding the escapes `JSON.stringify` and JavaScript produce. */
-  parseString() {
-    const quote = this.src[this.i];
-    let out = "";
-    this.i++;
-    while (this.i < this.src.length) {
-      const c = this.src[this.i];
-      if (c === quote) {
-        this.i++;
-        return out;
-      }
-      if (c !== "\\") {
-        out += c;
-        this.i++;
-        continue;
-      }
-      const next = this.src[this.i + 1];
-      if (next === void 0) break;
-      const simple = SIMPLE_ESCAPES[next];
-      if (simple !== void 0) {
-        out += simple;
-        this.i += 2;
-        continue;
-      }
-      const hex = next === "u" && this.src[this.i + 2] === "{" ? /^u\{([0-9a-fA-F]{1,6})\}/.exec(this.src.slice(this.i + 1)) : next === "u" ? /^u([0-9a-fA-F]{4})/.exec(this.src.slice(this.i + 1)) : next === "x" ? /^x([0-9a-fA-F]{2})/.exec(this.src.slice(this.i + 1)) : null;
-      if (hex) {
-        out += String.fromCodePoint(parseInt(hex[1], 16));
-        this.i += 1 + hex[0].length;
-        continue;
-      }
-      if (next === "u" || next === "x") this.fail("malformed escape");
-      out += next;
-      this.i += 2;
-    }
-    return this.fail("unterminated string");
+  "status",
+  "delay",
+  "dependency",
+  "data",
+  "extreme",
+  "replay",
+  "auth",
+  "slow-first"
+];
+function isFaultAllowed(level, fault) {
+  const list = level === "server" ? SERVER_PROBE_FAULTS : PROBE_FAULTS;
+  return list.includes(fault);
+}
+var SLOW_FAULT_DELAY_MS = 5e3;
+function faultRouteAction(fault) {
+  return fault === "slow" ? { kind: "delay", ms: SLOW_FAULT_DELAY_MS } : null;
+}
+function dropOneField(body) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(body);
+  } catch {
+    return body;
   }
-  parseRegex() {
-    let j = this.i + 1;
-    let inClass = false;
-    while (j < this.src.length) {
-      const c = this.src[j];
-      if (c === "\\") {
-        j += 2;
-        continue;
+  if (Array.isArray(parsed2)) {
+    let key;
+    for (const el of parsed2) {
+      if (el && typeof el === "object" && !Array.isArray(el)) {
+        key ??= Object.keys(el)[0];
+        if (key) delete el[key];
       }
-      if (c === "[") inClass = true;
-      else if (c === "]") inClass = false;
-      else if (c === "/" && !inClass) break;
-      j++;
     }
-    if (j >= this.src.length) this.fail("unterminated regex");
-    const source = this.src.slice(this.i + 1, j);
-    const flags = /^[a-z]*/.exec(this.src.slice(j + 1))[0];
-    this.i = j + 1 + flags.length;
-    return { type: "regex", source, flags };
+    return JSON.stringify(parsed2);
   }
-  parseObject() {
-    this.expect("{");
-    const entries = [];
-    for (; ; ) {
-      this.skipSpace();
-      if (this.peek() === "}") {
-        this.i++;
-        break;
-      }
-      const ch = this.peek();
-      const key = ch === "'" || ch === '"' ? this.parseString() : this.identifier();
-      this.expect(":");
-      entries.push([key, this.parseValue()]);
-      this.skipSpace();
-      if (this.peek() === ",") {
-        this.i++;
-        continue;
-      }
-      this.expect("}");
-      break;
+  if (parsed2 && typeof parsed2 === "object") {
+    const obj = parsed2;
+    const key = Object.keys(obj)[0];
+    if (key) delete obj[key];
+    return JSON.stringify(obj);
+  }
+  return body;
+}
+function computeFault(fault, input) {
+  const base = {
+    status: input.status,
+    body: input.body,
+    contentType: input.contentType ?? null,
+    delayMs: 0,
+    changed: false
+  };
+  switch (fault) {
+    case "status-500":
+      return { ...base, status: 500, changed: input.status !== 500 };
+    case "empty-body":
+      return { ...base, body: "", changed: input.body.length > 0 };
+    case "drop-field": {
+      const body = dropOneField(input.body);
+      return { ...base, body, changed: body !== input.body };
     }
-    return { type: "object", entries };
+    case "stale-value": {
+      const body = input.priorBody ?? input.body;
+      return { ...base, body, changed: body !== input.body };
+    }
+    case "slow":
+      return { ...base, delayMs: SLOW_FAULT_DELAY_MS, changed: true };
+    default:
+      return base;
   }
-};
-function parseLocatorChain(expr) {
-  const trimmed = expr.trim().replace(/^(?:await\s+)?(?:this\.)?page\./, "");
-  if (!trimmed) throw new LocatorParseError("empty expression");
-  return new Parser(trimmed).parseTopLevel();
 }
-function tryParseLocatorChain(expr) {
+
+// src/internal/probe/sign.ts
+var import_node_crypto = require("crypto");
+function signProbeMessage(secret, nonce, ts, specJson) {
+  return (0, import_node_crypto.createHmac)("sha256", secret).update(`${nonce}.${ts}.${specJson}`).digest("hex");
+}
+function buildProbeHeader(secret, spec, now = Date.now()) {
+  const nonce = (0, import_node_crypto.randomBytes)(8).toString("hex");
+  const specJson = JSON.stringify(spec);
+  const sig = signProbeMessage(secret, nonce, now, specJson);
+  return Buffer.from(JSON.stringify({ nonce, ts: now, specJson, sig }), "utf8").toString("base64");
+}
+
+// src/internal/probe/interception.ts
+function parseProbeTrace(traceHeader) {
+  const none = { appliedFault: null, serverError: false };
+  if (!traceHeader) return none;
   try {
-    return parseLocatorChain(expr);
+    const spans = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf8"));
+    if (!Array.isArray(spans)) return none;
+    const root = spans.find((s) => s && typeof s === "object" && !s.parentId);
+    if (!root) return none;
+    const attrs = root.attrs ?? {};
+    const appliedRaw = attrs["piwi.probe.applied"];
+    const status = Number(attrs["http.status_code"]) || 0;
+    return {
+      appliedFault: appliedRaw != null ? String(appliedRaw) : null,
+      serverError: root.status === "error" || status >= 500
+    };
+  } catch {
+    return none;
+  }
+}
+function fulfillHeaders(responseHeaders, contentType) {
+  const headers = { ...responseHeaders };
+  delete headers["content-length"];
+  delete headers["content-encoding"];
+  if (contentType) headers["content-type"] = contentType;
+  return headers;
+}
+function originOf(url) {
+  try {
+    const origin = new URL(url).origin;
+    return origin && origin !== "null" ? origin : null;
   } catch {
     return null;
   }
 }
-function parseLeafLocatorCall(expr) {
-  const chain = tryParseLocatorChain(expr);
-  if (!chain) return null;
-  for (let i = chain.calls.length - 1; i >= 0; i--) {
-    if (LOCATING_METHODS.has(chain.calls[i].method)) return chain.calls[i];
+var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, Math.max(0, ms)));
+async function performRouteAction(route, action, startedAt) {
+  switch (action.kind) {
+    case "abort":
+      await route.abort("connectionreset");
+      return;
+    case "status":
+      await route.fulfill({ status: action.status, body: "" });
+      return;
+    case "delay": {
+      const response = await route.fetch();
+      await sleep(startedAt + action.ms - Date.now());
+      await route.fulfill({ response });
+      return;
+    }
   }
-  return null;
 }
-function locatorCallValues(call, opts = {}) {
-  const value = (arg) => {
-    switch (arg.type) {
-      case "string":
-      case "number":
-      case "boolean":
-        return arg.value;
-      case "regex":
-        return opts.regexAsText ? `/${arg.source}/${arg.flags}` : void 0;
-      case "object": {
-        const out = {};
-        for (const [key, v] of arg.entries) {
-          const plain = value(v);
-          if (plain !== void 0) out[key] = plain;
-        }
-        return out;
+async function installRouteRules(page, rules) {
+  const state = rules.map(() => createProbeState());
+  page.on("framenavigated", (frame) => {
+    if (frame === page.mainFrame()) for (const s of state) markNavigated(s);
+  });
+  await page.route("**/*", async (route) => {
+    const startedAt = Date.now();
+    const request = route.request();
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      if (rule.done?.() || !rule.matches(request.method(), request.url())) continue;
+      if (!shouldAct(state[i], rule.match)) continue;
+      await rule.handle(route, startedAt);
+      return;
+    }
+    await route.fallback();
+  });
+  return { state };
+}
+async function installProbeInterception(page, item) {
+  if (!isFaultAllowed(item.level ?? "client", item.fault)) {
+    return { applied: () => false, appliedFault: () => null, serverError: () => false };
+  }
+  let applied = false;
+  let appliedFault = null;
+  let serverError = false;
+  let appOrigin = null;
+  const probeSecret = process.env[PIWI_PROBE_ENV.secret];
+  page.on("framenavigated", (frame) => {
+    if (frame === page.mainFrame()) {
+      const origin = originOf(page.url());
+      if (origin) appOrigin = origin;
+    }
+  });
+  const handle = async (route, startedAt) => {
+    const request = route.request();
+    if (item.level === "server") {
+      if (!probeSecret || appOrigin !== null && originOf(request.url()) !== appOrigin) {
+        await route.fallback();
+        return;
       }
-      case "chain":
-        return void 0;
+      const spec = { route: item.routeKey, fault: item.fault, nth: item.nth };
+      if (item.dependency) spec.dependency = item.dependency;
+      try {
+        const response = await route.fetch({
+          headers: { ...request.headers(), "x-piwi-probe": buildProbeHeader(probeSecret, spec) }
+        });
+        const trace = parseProbeTrace(response.headers()["x-piwi-trace"]);
+        appliedFault = trace.appliedFault;
+        serverError = trace.serverError;
+        applied = trace.appliedFault != null && trace.appliedFault.split(":", 1)[0] === item.fault;
+        await route.fulfill({ response });
+      } catch {
+        applied = false;
+        await route.fallback();
+      }
+      return;
+    }
+    try {
+      const action = faultRouteAction(item.fault);
+      if (action) {
+        applied = true;
+        appliedFault = item.fault;
+        await performRouteAction(route, action, startedAt);
+        return;
+      }
+      const response = await route.fetch();
+      const body = await response.text();
+      const out = computeFault(item.fault, {
+        status: response.status(),
+        body,
+        contentType: response.headers()["content-type"] ?? null
+      });
+      applied = out.changed;
+      if (applied) appliedFault = item.fault;
+      const headers = fulfillHeaders(response.headers(), out.contentType);
+      await route.fulfill({ status: out.status, body: out.body, headers });
+    } catch {
+      applied = false;
+      await route.fallback();
     }
   };
-  return call.args.map(value).filter((v) => v !== void 0);
+  await installRouteRules(page, [
+    {
+      matches: (method, url) => requestMatchesRoute(method, url, item.routeKey),
+      match: Math.max(1, item.nth ?? 1),
+      handle,
+      done: () => applied
+    }
+  ]);
+  return { applied: () => applied, appliedFault: () => appliedFault, serverError: () => serverError };
 }
 
+// src/internal/flake/mode.ts
+var fs3 = __toESM(require("fs"));
+
 // ../core/src/error-parse.ts
 var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
 function stripAnsi(text) {
@@ -3053,11 +3082,20 @@ function extractMessageHead(text) {
   let head = text;
   const callLogIdx = head.indexOf("\nCall log:");
   if (callLogIdx !== -1) head = head.slice(0, callLogIdx);
-  const stackIdx = head.search(/\n\s+at /);
+  const stackIdx = stackStart(head);
   if (stackIdx !== -1) head = head.slice(0, stackIdx);
   const lines = head.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
   return lines.slice(0, 5).join("\n");
 }
+function stackStart(text) {
+  const runs = /\s+/g;
+  for (let run = runs.exec(text); run; run = runs.exec(text)) {
+    if (!text.startsWith("at ", runs.lastIndex)) continue;
+    const lineBreak = run[0].indexOf("\n");
+    if (lineBreak !== -1 && lineBreak < run[0].length - 1) return run.index + lineBreak;
+  }
+  return -1;
+}
 function extractSelector(text) {
   const match = SELECTOR_FN_RE.exec(text);
   if (!match) return null;
@@ -3078,7 +3116,7 @@ function extractSelector(text) {
 }
 var LEAF_METHODS = new Set(LOCATOR_BUILDER_METHODS);
 function extractStackFrames(text) {
-  const frameRe = /^\s+at (?:.*? \()?([^()\s][^()]*?):(\d+):(\d+)\)?\s*$/gm;
+  const frameRe = /^[ \t]+at (?:.*? \()?([^()\s][^()\n]*?):(\d+):(\d+)\)?[ \t]*$/gm;
   const frames = [];
   let m;
   while ((m = frameRe.exec(text)) !== null) {
@@ -3096,6 +3134,11 @@ function extractTopFrameFile(text) {
 }
 var SUBJECTS = "locator|page|frame|frameLocator|elementHandle|mouse|keyboard|touchscreen|browserContext|browser|apiRequestContext|request|response|route|download|dialog|fileChooser|expect|worker|jsHandle|clock|tracing|video";
 var CALL_RE = new RegExp(`\\b(${SUBJECTS})\\.(\\w+): `);
+function readLocatorHeader(text) {
+  const header = /^[ \t]*Locator:[ \t]*(.+)$/m.exec(text);
+  return header ? header[1].trim() : null;
+}
+var MAX_PARSED_ERROR_CHARS = 64 * 1024;
 
 // ../core/src/error-signature.ts
 var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
@@ -3338,12 +3381,12 @@ function loadFlakePlan() {
     throw new Error(`[Piwi Dashboard] ${errorMessage(error)} (${file})`);
   }
 }
-function relativeTestFile(file) {
-  return file ? path4.relative(process.cwd(), file).split(path4.sep).join("/") : null;
+function relativeTestFile(file, base = process.cwd()) {
+  return file ? relativeTestPath(file, base) : null;
 }
 function flakeRoleForTest(plan, test) {
   const running = {
-    file: relativeTestFile(test.file),
+    file: relativeTestFile(test.file, test.base),
     title: test.title,
     suite: test.titlePath ? test.titlePath.slice(1, -1) : void 0
   };
@@ -3459,7 +3502,7 @@ function flakeResultLine(plan, attempt) {
     experimentId: plan.experimentId,
     armId: plan.arm.id,
     role: attempt.role,
-    file: relativeTestFile(attempt.file),
+    file: relativeTestFile(attempt.file, attempt.base),
     title: attempt.title,
     project: attempt.project,
     browserName: attempt.browserName,
@@ -3485,20 +3528,468 @@ function recordFlakeResult(line) {
   }
 }
 
-// ../core/src/error-text.ts
-function joinErrorMessages(errors) {
-  if (!errors || errors.length === 0) return null;
-  const seen = /* @__PURE__ */ new Set();
-  const parts = [];
-  for (const err of errors) {
-    const msg = err.message ?? "";
-    if (!msg) continue;
-    const dedupeKey = msg.trim().slice(0, 200);
-    if (seen.has(dedupeKey)) continue;
-    seen.add(dedupeKey);
-    parts.push(msg);
-  }
-  return parts.join("\n---\n") || null;
+// ../core/src/error-text.ts
+function joinErrorMessages(errors) {
+  if (!errors || errors.length === 0) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const err of errors) {
+    const msg = err.message ?? "";
+    if (!msg) continue;
+    const dedupeKey = msg.trim().slice(0, 200);
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    parts.push(msg);
+  }
+  return parts.join("\n---\n") || null;
+}
+
+// ../core/src/coverage.ts
+var MAX_COVERAGE_FILES = 2e3;
+var MAX_COVERAGE_RANGES = 1e4;
+var MAX_LINE = 1e6;
+var MAX_PATH_LENGTH = 500;
+var BLOB_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRuntime(value) {
+  return value === "browser" || value === "server";
+}
+function isLine(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_LINE;
+}
+function validRanges(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!Array.isArray(item) || item.length !== 2) continue;
+    const [start, end] = item;
+    if (isLine(start) && isLine(end) && start <= end) out.push([start, end]);
+  }
+  return out.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+function normalizeLineRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (last && range[0] <= last[1] + 1) last[1] = Math.max(last[1], range[1]);
+    else out.push(range);
+  }
+  return out;
+}
+function normalizeFunctionRanges(ranges) {
+  const out = [];
+  for (const range of validRanges(ranges)) {
+    const last = out[out.length - 1];
+    if (!last || last[0] !== range[0] || last[1] !== range[1]) out.push(range);
+  }
+  return out;
+}
+function normalizeCoveragePath(raw) {
+  if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
+  const path13 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!path13 || path13.startsWith("../") || path13.startsWith("/") || /^[A-Za-z]:\//.test(path13)) return null;
+  if (/(^|\/)node_modules\//.test(path13)) return null;
+  return path13;
+}
+function fileEntry(path13, runtime, blob, functions = [], lines = []) {
+  const file = { path: path13, runtime };
+  if (blob && (functions.length > 0 || lines.length > 0)) file.blob = blob;
+  if (functions.length > 0) file.functions = functions;
+  if (lines.length > 0) file.lines = lines;
+  return file;
+}
+function captureOf(files, incomplete) {
+  return incomplete ? { v: 1, files, incomplete: true } : { v: 1, files };
+}
+function compareFiles(a, b) {
+  if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+  if (a.runtime !== b.runtime) return a.runtime < b.runtime ? -1 : 1;
+  return 0;
+}
+function sanitizeCoverage(raw) {
+  if (!isRecord(raw) || raw.v !== 1 || !Array.isArray(raw.files)) return null;
+  const files = [];
+  for (const item of raw.files) {
+    if (!isRecord(item) || !isRuntime(item.runtime)) continue;
+    const path13 = normalizeCoveragePath(item.path);
+    if (path13 === null) continue;
+    const blob = typeof item.blob === "string" && BLOB_ID.test(item.blob) ? item.blob : void 0;
+    files.push(
+      fileEntry(path13, item.runtime, blob, normalizeFunctionRanges(item.functions), normalizeLineRanges(item.lines))
+    );
+  }
+  const merged = mergeCoverage(captureOf(files, raw.incomplete === true));
+  if (!merged) return null;
+  let incomplete = merged.incomplete === true || merged.files.length > MAX_COVERAGE_FILES;
+  let budget = MAX_COVERAGE_RANGES;
+  const capped = merged.files.slice(0, MAX_COVERAGE_FILES).map((file) => {
+    const count = (file.functions?.length ?? 0) + (file.lines?.length ?? 0);
+    if (count <= budget) {
+      budget -= count;
+      return file;
+    }
+    incomplete = true;
+    return fileEntry(file.path, file.runtime);
+  });
+  return captureOf(capped, incomplete);
+}
+function mergeCoverage(...captures2) {
+  const entries = /* @__PURE__ */ new Map();
+  let incomplete = false;
+  for (const capture of captures2) {
+    if (!capture) continue;
+    if (capture.incomplete) incomplete = true;
+    for (const file of capture.files) {
+      const key = `${file.runtime}:${file.path}`;
+      let entry = entries.get(key);
+      if (!entry) {
+        entry = { path: file.path, runtime: file.runtime, blobs: /* @__PURE__ */ new Set(), functions: [], lines: [] };
+        entries.set(key, entry);
+      }
+      if (file.blob) entry.blobs.add(file.blob);
+      for (const range of file.functions ?? []) entry.functions.push(range);
+      for (const range of file.lines ?? []) entry.lines.push(range);
+    }
+  }
+  if (entries.size === 0) return null;
+  const files = [...entries.values()].map((entry) => {
+    if (entry.blobs.size > 1) incomplete = true;
+    const blob = entry.blobs.size === 1 ? [...entry.blobs][0] : void 0;
+    return fileEntry(
+      entry.path,
+      entry.runtime,
+      blob,
+      normalizeFunctionRanges(entry.functions),
+      normalizeLineRanges(entry.lines)
+    );
+  });
+  return captureOf(files.sort(compareFiles), incomplete);
+}
+
+// ../core/src/source-map.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_VALUE = new Int8Array(128).fill(-1);
+for (let i = 0; i < BASE64.length; i++) BASE64_VALUE[BASE64.charCodeAt(i)] = i;
+function decodeMappings(mappings, sourceBase) {
+  const lines = [];
+  let current = { columns: [], sources: [], originalLines: [] };
+  let column = 0;
+  let source = 0;
+  let originalLine = 0;
+  const fields = [];
+  let value = 0;
+  let shift = 0;
+  const flush = () => {
+    if (fields.length === 0) return;
+    column += fields[0];
+    if (fields.length >= 4) {
+      source += fields[1];
+      originalLine += fields[2];
+      current.columns.push(column);
+      current.sources.push(sourceBase + source);
+      current.originalLines.push(originalLine);
+    } else {
+      current.columns.push(column);
+      current.sources.push(-1);
+      current.originalLines.push(-1);
+    }
+    fields.length = 0;
+  };
+  for (let i = 0; i <= mappings.length; i++) {
+    const ch = i < mappings.length ? mappings.charCodeAt(i) : 59;
+    if (ch === 59 || ch === 44) {
+      flush();
+      if (ch === 59) {
+        lines.push(current);
+        current = { columns: [], sources: [], originalLines: [] };
+        column = 0;
+      }
+      continue;
+    }
+    const digit = ch < 128 ? BASE64_VALUE[ch] : -1;
+    if (digit < 0) continue;
+    value += (digit & 31) << shift;
+    if (digit & 32) {
+      shift += 5;
+      continue;
+    }
+    fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
+    value = 0;
+    shift = 0;
+  }
+  for (const line of lines) {
+    if (line.columns.every((c, i) => i === 0 || c >= line.columns[i - 1])) continue;
+    const order = line.columns.map((_, i) => i).sort((a, b) => line.columns[a] - line.columns[b]);
+    line.columns = order.map((i) => line.columns[i]);
+    line.sources = order.map((i) => line.sources[i]);
+    line.originalLines = order.map((i) => line.originalLines[i]);
+  }
+  return lines;
+}
+function joinRoot(root, source) {
+  if (!root || /^[a-z][\w+.-]*:/i.test(source) || source.startsWith("/")) return source;
+  return root.endsWith("/") ? root + source : `${root}/${source}`;
+}
+function decodeLines(raw) {
+  const sources = [];
+  const decoded = [];
+  const add = (map, lineOffset, columnOffset) => {
+    if (map.sections) {
+      for (const section of map.sections) {
+        if (!add(section.map, section.offset.line, section.offset.column)) return false;
+      }
+      return true;
+    }
+    if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return false;
+    const base = sources.length;
+    for (const s of map.sources) sources.push(joinRoot(map.sourceRoot, s ?? ""));
+    decodeMappings(map.mappings, base).forEach((segments, i) => {
+      const at = lineOffset + i;
+      const shifted = i === 0 && columnOffset ? segments.columns.map((c) => c + columnOffset) : segments.columns;
+      const existing = decoded[at];
+      if (!existing)
+        decoded[at] = { columns: shifted, sources: segments.sources, originalLines: segments.originalLines };
+      else {
+        existing.columns.push(...shifted);
+        existing.sources.push(...segments.sources);
+        existing.originalLines.push(...segments.originalLines);
+      }
+    });
+    return true;
+  };
+  return add(raw, 0, 0) ? { sources, lines: decoded } : null;
+}
+function compactSegments(lines) {
+  let total = 0;
+  for (const line of lines) total += line?.columns.length ?? 0;
+  const segments = {
+    lineStarts: new Int32Array(lines.length + 1),
+    columns: new Int32Array(total),
+    sources: new Int32Array(total),
+    originalLines: new Int32Array(total)
+  };
+  let at = 0;
+  for (let n = 0; n < lines.length; n++) {
+    segments.lineStarts[n] = at;
+    const line = lines[n];
+    if (!line) continue;
+    segments.columns.set(line.columns, at);
+    segments.sources.set(line.sources, at);
+    segments.originalLines.set(line.originalLines, at);
+    at += line.columns.length;
+  }
+  segments.lineStarts[lines.length] = at;
+  return segments;
+}
+function decodeSourceMap(raw) {
+  if (raw.version !== void 0 && raw.version !== 3) return null;
+  const decoded = decodeLines(raw);
+  if (!decoded) return null;
+  const { sources } = decoded;
+  const segments = compactSegments(decoded.lines);
+  const lineCount = segments.lineStarts.length - 1;
+  const originalAt = (line, column) => {
+    if (line < 0 || line >= lineCount) return null;
+    let lo = segments.lineStarts[line];
+    let hi = segments.lineStarts[line + 1] - 1;
+    if (lo > hi || segments.columns[lo] > column) return null;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (segments.columns[mid] <= column) lo = mid;
+      else hi = mid - 1;
+    }
+    const source = segments.sources[lo];
+    return source < 0 ? null : { source, line: segments.originalLines[lo] };
+  };
+  return {
+    sources,
+    sourceAt(line, column) {
+      return originalAt(line, column)?.source ?? null;
+    },
+    originalAt,
+    firstOriginalLineBetween(source, start, end) {
+      let first = null;
+      eachSegmentBetween(segments, start, end, (i) => {
+        if (segments.sources[i] !== source || segments.originalLines[i] < 0) return false;
+        first = segments.originalLines[i];
+        return true;
+      });
+      return first;
+    },
+    originalLinesBetween(source, start, end, fromLine = 0) {
+      let first = Number.POSITIVE_INFINITY;
+      let last = -1;
+      eachSegmentBetween(segments, start, end, (i) => {
+        const line = segments.originalLines[i];
+        if (segments.sources[i] === source && line >= fromLine) {
+          if (line < first) first = line;
+          if (line > last) last = line;
+        }
+        return false;
+      });
+      return last < 0 ? null : [first, last];
+    }
+  };
+}
+function eachSegmentBetween(segments, start, end, visit) {
+  const lineCount = segments.lineStarts.length - 1;
+  for (let line = Math.max(start.line, 0); line <= end.line && line < lineCount; line++) {
+    let i = segments.lineStarts[line];
+    const stop = segments.lineStarts[line + 1];
+    if (line === start.line) {
+      let hi = stop;
+      while (i < hi) {
+        const mid = i + hi >> 1;
+        if (segments.columns[mid] < start.column) i = mid + 1;
+        else hi = mid;
+      }
+    }
+    for (; i < stop; i++) {
+      if (line === end.line && segments.columns[i] >= end.column) return;
+      if (visit(i)) return;
+    }
+  }
+}
+function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  return starts;
+}
+function offsetToPosition(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo, column: offset - starts[lo] };
+}
+function sourceMappingUrl(script) {
+  const tail = script.slice(-4096);
+  const matches = [...tail.matchAll(/(?:\/\/|\/\*)[#@]\s*sourceMappingURL=([^\s*'"]+)/g)];
+  return matches.length ? matches[matches.length - 1][1] : null;
+}
+function decodeDataUrl(url) {
+  const m = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(url);
+  if (!m) return null;
+  try {
+    if (!m[2]) return decodeURIComponent(m[3]);
+    const binary = globalThis.atob(m[3]);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function normalizeSourcePath(source) {
+  let s = source.replace(/[?#].*$/, "");
+  s = s.replace(/^webpack:\/\/[^/]*\//, "").replace(/^webpack:\/\//, "");
+  s = s.replace(/^(?:vite|rollup|turbopack|ng):\/*/, "");
+  s = s.replace(/^\[project\]\//, "");
+  s = s.replace(/^file:\/\//, "");
+  s = s.replace(/^\/@fs\//, "/");
+  s = s.replace(/^\/@id\//, "");
+  try {
+    s = decodeURIComponent(s);
+  } catch {
+  }
+  s = s.replace(/\\/g, "/");
+  if (/^\/[A-Za-z]:\//.test(s)) s = s.slice(1);
+  s = s.replace(/(^|\/)\.\//g, "$1");
+  return s;
+}
+
+// ../core/src/code-reach.ts
+var MAX_CODE_REACH_FILES = 2e3;
+function scriptText(source) {
+  return { length: source.length, starts: Uint32Array.from(lineStarts(source)) };
+}
+var textOf = (entry, text) => text ?? (entry.source === void 0 ? void 0 : scriptText(entry.source));
+function executedFunctionRanges(entry, length, all = false) {
+  length ??= entry.source?.length ?? Number.POSITIVE_INFINITY;
+  const out = [];
+  entry.functions.forEach((fn, i) => {
+    const whole = fn.ranges[0];
+    if (!whole || !all && whole.count <= 0) return;
+    const topLevel = whole.startOffset === 0 && (whole.endOffset >= length || i === 0 && fn.functionName === "");
+    if (topLevel) return;
+    out.push({ start: whole.startOffset, end: whole.endOffset });
+  });
+  return out;
+}
+function scriptRan(entry, text) {
+  return executedFunctionRanges(entry, text?.length).length > 0;
+}
+function reachedFunctionLines(entry, map, text) {
+  return functionLines(entry, map, text, false);
+}
+function knownFunctionLines(entry, map, text) {
+  return functionLines(entry, map, text, true);
+}
+function functionLines(entry, map, text, all) {
+  const out = /* @__PURE__ */ new Map();
+  const read = textOf(entry, text);
+  const ranges = executedFunctionRanges(entry, read?.length, all);
+  if (!ranges.length || !read) return out;
+  const add = (source, range) => {
+    const list = out.get(source);
+    if (list) list.push(range);
+    else out.set(source, [range]);
+  };
+  const starts = read.starts;
+  for (const range of ranges) {
+    const start = offsetToPosition(starts, range.start);
+    if (!map) {
+      const last = offsetToPosition(starts, Math.max(range.start, range.end - 1));
+      add(-1, [start.line + 1, last.line + 1]);
+      continue;
+    }
+    const at = map.originalAt(start.line, start.column);
+    if (at === null) continue;
+    const end = offsetToPosition(starts, range.end);
+    const first = map.firstOriginalLineBetween(at.source, start, end);
+    if (first === null) continue;
+    const header = first === at.line || first === at.line + 1 ? at.line : first;
+    const lines = map.originalLinesBetween(at.source, start, end, header);
+    if (lines) add(at.source, [header + 1, lines[1] + 1]);
+  }
+  return out;
+}
+function finalizeCodeReach(files) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of files) {
+    const file = normalizeCoveragePath(raw);
+    if (file !== null) out.add(file);
+  }
+  return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
+}
+
+// ../core/src/mask.ts
+var DATA_URI_RE = /\bdata:[a-z0-9.+-]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi;
+var JWT_RE = /\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g;
+var LONG_HEX_RE2 = /\b[0-9a-f]{32,}\b/gi;
+function maskTokenLike(text) {
+  return text.replace(DATA_URI_RE, "data:[masked]").replace(JWT_RE, "[masked-token]").replace(LONG_HEX_RE2, "[masked-hex]");
+}
+var CREDENTIAL_PARAM_RE = /token|code|secret|password|passwd|pwd|key|session|auth|sig|credential|assertion|nonce|otp|jwt/i;
+function maskUrlFragment(hash) {
+  const body = hash.startsWith("#") ? hash.slice(1) : hash;
+  const query = body.indexOf("?");
+  const route = query >= 0 ? body.slice(0, query) : body.includes("=") ? "" : body;
+  const params = query >= 0 ? body.slice(query + 1) : body.includes("=") ? body : null;
+  const masked = params === null ? null : params.split("&").map((param) => {
+    const eq = param.indexOf("=");
+    if (eq < 0) return maskTokenLike(param);
+    const name = param.slice(0, eq);
+    const value = param.slice(eq + 1);
+    return `${name}=${value && CREDENTIAL_PARAM_RE.test(name) ? "[masked]" : maskTokenLike(value)}`;
+  }).join("&");
+  const out = maskTokenLike(route) + (masked === null ? "" : query >= 0 ? `?${masked}` : masked);
+  return hash.startsWith("#") ? `#${out}` : out;
 }
 
 // src/internal/capture/inspect-on-failure.ts
@@ -3537,8 +4028,7 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path5 = __toESM(require("path"));
-var ANSI_RE2 = /\x1b\[[0-9;]*m/g;
+var path4 = __toESM(require("path"));
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
   return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
@@ -3547,14 +4037,13 @@ function deriveFailedLocator(testInfo) {
   const info = testInfo;
   const errors = info.errors && info.errors.length > 0 ? info.errors : info.error ? [info.error] : [];
   for (const err of errors) {
-    const text = `${err.message ?? ""}
-${err.stack ?? ""}`.replace(ANSI_RE2, "");
-    const line = /^\s*Locator:\s*(.+)$/m.exec(text);
-    if (!line) continue;
-    const parsed2 = parseLeafLocatorExpression(line[1].trim());
+    const header = readLocatorHeader(stripAnsi(`${err.message ?? ""}
+${err.stack ?? ""}`));
+    if (!header) continue;
+    const parsed2 = parseLeafLocatorExpression(header);
     if (!parsed2) continue;
     const loc = err.location;
-    const location = loc ? `${path5.relative(process.cwd(), loc.file).split(path5.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path4.relative(process.cwd(), loc.file).split(path4.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed2.method, args: parsed2.args, location };
   }
   return null;
@@ -3707,7 +4196,7 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/capture/pause-at.ts
-var path6 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 
 // ../core/src/editor-send.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
@@ -3751,9 +4240,9 @@ var PauseSet = class {
 var EMPTY = new PauseSet(/* @__PURE__ */ new Set());
 function callSiteFile(file, cwd) {
   const slashed = file.replace(/\\/g, "/");
-  const absolute = path6.isAbsolute(file) || path6.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
-  let rel = absolute ? path6.relative(cwd, file) : path6.normalize(slashed);
-  rel = rel.split(path6.sep).join("/").replace(/\\/g, "/");
+  const absolute = path5.isAbsolute(file) || path5.isAbsolute(slashed) || /^[A-Za-z]:\//.test(slashed);
+  let rel = absolute ? path5.relative(cwd, file) : path5.normalize(slashed);
+  rel = rel.split(path5.sep).join("/").replace(/\\/g, "/");
   if (rel.startsWith("./")) rel = rel.slice(2);
   return rel;
 }
@@ -3909,385 +4398,194 @@ function isServerGranularity(value) {
   return typeof value === "string" && SERVER_VALUES.has(value);
 }
 function browserCoverageInWorker() {
-  return process.env[PIWI_ENV_KEYS.captureCodeReach] === "true" || process.env[PIWI_ENV_KEYS.coverageBrowser] === "files";
-}
-function serverCoverageInWorker() {
-  return isServerGranularity(process.env[PIWI_ENV_KEYS.coverageServer]);
-}
-
-// src/internal/support/aria-sampling.ts
-var path7 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
-var fs4 = __toESM(require("fs"));
-
-// src/internal/support/instance-id.ts
-var crypto = __toESM(require("crypto"));
-var os2 = __toESM(require("os"));
-function hashForProject(projectName) {
-  return crypto.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
-}
-
-// src/internal/support/aria-sampling.ts
-function ariaSampleIdentity(filePath, title) {
-  return `${filePath}\0${title}`;
-}
-function getAriaSampleFilePath(projectName) {
-  return path7.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
-}
-var cachedSets = /* @__PURE__ */ new Map();
-function loadAriaSampleSet(projectName) {
-  if (cachedSets.has(projectName)) return cachedSets.get(projectName);
-  let set = null;
-  try {
-    const raw = fs4.readFileSync(getAriaSampleFilePath(projectName), "utf8");
-    const parsed2 = JSON.parse(raw);
-    if (parsed2.projectName === projectName && Array.isArray(parsed2.identities)) {
-      set = new Set(parsed2.identities.filter((x) => typeof x === "string"));
-    }
-  } catch {
-    set = null;
-  }
-  cachedSets.set(projectName, set);
-  return set;
-}
-function relativeTestFile2(file) {
-  return path7.relative(process.cwd(), file).split(path7.sep).join("/");
-}
-function isDueForAriaSample(testInfo) {
-  const projectName = process.env.PIWI_PROJECT_NAME;
-  if (!projectName) return false;
-  const set = loadAriaSampleSet(projectName);
-  if (!set || set.size === 0) return false;
-  return set.has(ariaSampleIdentity(relativeTestFile2(testInfo.file), testInfo.title));
-}
-
-// src/internal/capture/quiet-capture.ts
-var import_node_module = require("module");
-var path9 = __toESM(require("path"));
-
-// src/internal/support/reporter-version.ts
-var fs5 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
-var CANDIDATE_OFFSETS = ["..", "../../.."];
-function findOwnPackageJson(fromDir) {
-  for (const offset of CANDIDATE_OFFSETS) {
-    try {
-      const pkgPath = path8.resolve(fromDir, offset, "package.json");
-      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-      const { name, version } = pkg;
-      if (name === "@piwitests/reporter" && typeof version === "string")
-        return { version, root: path8.dirname(pkgPath) };
-    } catch {
-    }
-  }
-  return void 0;
-}
-
-// src/internal/capture/quiet-capture.ts
-var BOXED_PREFIX_EXPORTS = [
-  [
-    "playwright-core/lib/coreBundle",
-    (mod) => mod?.utils?.setBoxedStackPrefixes
-  ],
-  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
-];
-var boxing;
-var resolvedPlaywrightPackageJson;
-function resolvePlaywrightPackageJson() {
-  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
-  try {
-    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
-    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
-  } catch {
-    resolvedPlaywrightPackageJson = null;
-  }
-  return resolvedPlaywrightPackageJson;
-}
-function resolveBoxing() {
-  try {
-    const root = findOwnPackageJson(__dirname)?.root;
-    if (!root) return null;
-    const playwrightPackageJson = resolvePlaywrightPackageJson();
-    if (!playwrightPackageJson) return null;
-    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
-    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
-      let set;
-      try {
-        set = pick(requireFromPlaywright(moduleId));
-      } catch {
-        continue;
-      }
-      if (typeof set !== "function") continue;
-      return {
-        set,
-        prefixes: [path9.dirname(playwrightPackageJson), path9.join(root, "dist") + path9.sep]
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-function boxCaptureFrames(extraPrefixes = []) {
-  const first = boxing === void 0;
-  if (first) boxing = resolveBoxing();
-  if (!boxing) return;
-  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
-  if (!first && added.length === 0) return;
-  boxing.prefixes.push(...added);
-  try {
-    boxing.set([...boxing.prefixes]);
-  } catch {
-  }
-}
-function callMethod(target, prop, args) {
-  return target[prop](...args);
-}
-function internalCall(owner, run) {
-  const wrap = owner?._wrapApiCall;
-  if (typeof wrap !== "function") return run();
-  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
-}
-
-// src/internal/capture/code-reach.ts
-var crypto2 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
-var import_node_child_process = require("child_process");
-
-// ../core/src/coverage.ts
-var MAX_PATH_LENGTH = 500;
-function normalizeCoveragePath(raw) {
-  if (typeof raw !== "string" || raw.length > MAX_PATH_LENGTH || raw.includes("\0")) return null;
-  const path14 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (!path14 || path14.startsWith("../") || path14.startsWith("/") || /^[A-Za-z]:\//.test(path14)) return null;
-  if (/(^|\/)node_modules\//.test(path14)) return null;
-  return path14;
+  const browser = process.env[PIWI_ENV_KEYS.coverageBrowser];
+  return process.env[PIWI_ENV_KEYS.captureCodeReach] === "true" || browser === "files" || browser === "functions";
 }
-
-// ../core/src/source-map.ts
-var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var BASE64_VALUE = new Int8Array(128).fill(-1);
-for (let i = 0; i < BASE64.length; i++) BASE64_VALUE[BASE64.charCodeAt(i)] = i;
-function decodeMappings(mappings, sourceBase) {
-  const lines = [];
-  let current = { columns: [], sources: [] };
-  let column = 0;
-  let source = 0;
-  const fields = [];
-  let value = 0;
-  let shift = 0;
-  const flush = () => {
-    if (fields.length === 0) return;
-    column += fields[0];
-    if (fields.length >= 4) {
-      source += fields[1];
-      current.columns.push(column);
-      current.sources.push(sourceBase + source);
-    } else {
-      current.columns.push(column);
-      current.sources.push(-1);
-    }
-    fields.length = 0;
-  };
-  for (let i = 0; i <= mappings.length; i++) {
-    const ch = i < mappings.length ? mappings.charCodeAt(i) : 59;
-    if (ch === 59 || ch === 44) {
-      flush();
-      if (ch === 59) {
-        lines.push(current);
-        current = { columns: [], sources: [] };
-        column = 0;
-      }
-      continue;
-    }
-    const digit = ch < 128 ? BASE64_VALUE[ch] : -1;
-    if (digit < 0) continue;
-    value += (digit & 31) << shift;
-    if (digit & 32) {
-      shift += 5;
-      continue;
-    }
-    fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
-    value = 0;
-    shift = 0;
-  }
-  for (const line of lines) {
-    if (line.columns.every((c, i) => i === 0 || c >= line.columns[i - 1])) continue;
-    const order = line.columns.map((_, i) => i).sort((a, b) => line.columns[a] - line.columns[b]);
-    line.columns = order.map((i) => line.columns[i]);
-    line.sources = order.map((i) => line.sources[i]);
-  }
-  return lines;
+function browserFunctionsInWorker() {
+  return process.env[PIWI_ENV_KEYS.coverageBrowser] === "functions";
 }
-function joinRoot(root, source) {
-  if (!root || /^[a-z][\w+.-]*:/i.test(source) || source.startsWith("/")) return source;
-  return root.endsWith("/") ? root + source : `${root}/${source}`;
+function browserFunctionCoverage(files) {
+  return sanitizeCoverage({
+    v: 1,
+    files: [...files].map(([path13, functions]) => ({ path: path13, runtime: "browser", functions }))
+  });
 }
-function decodeSourceMap(raw) {
-  const sources = [];
-  const lines = [];
-  const add = (map, lineOffset, columnOffset) => {
-    if (map.sections) {
-      for (const section of map.sections) {
-        if (!add(section.map, section.offset.line, section.offset.column)) return false;
-      }
-      return true;
-    }
-    if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return false;
-    const base = sources.length;
-    for (const s of map.sources) sources.push(joinRoot(map.sourceRoot, s ?? ""));
-    decodeMappings(map.mappings, base).forEach((segments, i) => {
-      const at = lineOffset + i;
-      const shifted = i === 0 && columnOffset ? segments.columns.map((c) => c + columnOffset) : segments.columns;
-      const existing = lines[at];
-      if (!existing) lines[at] = { columns: shifted, sources: segments.sources };
-      else {
-        existing.columns.push(...shifted);
-        existing.sources.push(...segments.sources);
-      }
-    });
-    return true;
-  };
-  if (raw.version !== void 0 && raw.version !== 3) return null;
-  if (!add(raw, 0, 0)) return null;
-  return {
-    sources,
-    sourceAt(line, column) {
-      const segments = lines[line];
-      if (!segments || segments.columns.length === 0) return null;
-      let lo = 0;
-      let hi = segments.columns.length - 1;
-      if (segments.columns[0] > column) return null;
-      while (lo < hi) {
-        const mid = lo + hi + 1 >> 1;
-        if (segments.columns[mid] <= column) lo = mid;
-        else hi = mid - 1;
-      }
-      const source = segments.sources[lo];
-      return source < 0 ? null : source;
-    },
-    mapsBetween(source, start, end) {
-      for (let line = start.line; line <= end.line && line < lines.length; line++) {
-        const segments = lines[line];
-        if (!segments) continue;
-        let i = 0;
-        if (line === start.line) {
-          let hi = segments.columns.length;
-          while (i < hi) {
-            const mid = i + hi >> 1;
-            if (segments.columns[mid] < start.column) i = mid + 1;
-            else hi = mid;
-          }
-        }
-        for (; i < segments.columns.length; i++) {
-          if (line === end.line && segments.columns[i] >= end.column) return false;
-          if (segments.sources[i] === source) return true;
-        }
-      }
-      return false;
-    }
+function newKnownFunctions(known, sent) {
+  const parts = [];
+  let files = [];
+  let budget = MAX_COVERAGE_RANGES;
+  const close = () => {
+    if (files.length > 0) parts.push({ v: 1, files: files.sort((a, b) => a.path < b.path ? -1 : 1) });
+    files = [];
+    budget = MAX_COVERAGE_RANGES;
   };
+  for (const [raw, ranges] of known) {
+    const path13 = normalizeCoveragePath(raw);
+    if (path13 === null) continue;
+    let named = sent.get(path13);
+    let fresh = normalizeFunctionRanges(ranges).filter((range) => !named?.has(`${range[0]}:${range[1]}`));
+    if (fresh.length === 0) continue;
+    if (!named) sent.set(path13, named = /* @__PURE__ */ new Set());
+    for (const range of fresh) named.add(`${range[0]}:${range[1]}`);
+    while (fresh.length > 0) {
+      if (budget === 0 || files.length >= MAX_COVERAGE_FILES) close();
+      const part = fresh.slice(0, budget);
+      fresh = fresh.slice(part.length);
+      budget -= part.length;
+      files.push({ path: path13, allFunctions: part });
+    }
+  }
+  close();
+  return parts;
 }
-function lineStarts(text) {
-  const starts = [0];
-  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
-  return starts;
+function serverCoverageInWorker() {
+  return isServerGranularity(process.env[PIWI_ENV_KEYS.coverageServer]);
 }
-function offsetToPosition(starts, offset) {
-  let lo = 0;
-  let hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
-  }
-  return { line: lo, column: offset - starts[lo] };
+
+// src/internal/support/aria-sampling.ts
+var path6 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var fs4 = __toESM(require("fs"));
+
+// src/internal/support/instance-id.ts
+var crypto = __toESM(require("crypto"));
+var os2 = __toESM(require("os"));
+function hashForProject(projectName) {
+  return crypto.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
 }
-function sourceMappingUrl(script) {
-  const tail = script.slice(-4096);
-  const matches = [...tail.matchAll(/(?:\/\/|\/\*)[#@]\s*sourceMappingURL=([^\s*'"]+)/g)];
-  return matches.length ? matches[matches.length - 1][1] : null;
+
+// src/internal/support/aria-sampling.ts
+function ariaSampleIdentity(filePath, title) {
+  return `${filePath}\0${title}`;
 }
-function decodeDataUrl(url) {
-  const m = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(url);
-  if (!m) return null;
-  try {
-    if (!m[2]) return decodeURIComponent(m[3]);
-    const binary = globalThis.atob(m[3]);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return new TextDecoder().decode(bytes);
-  } catch {
-    return null;
-  }
+function getAriaSampleFilePath(projectName) {
+  return path6.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
 }
-function normalizeSourcePath(source) {
-  let s = source.replace(/[?#].*$/, "");
-  s = s.replace(/^webpack:\/\/[^/]*\//, "").replace(/^webpack:\/\//, "");
-  s = s.replace(/^(?:vite|rollup|turbopack|ng):\/*/, "");
-  s = s.replace(/^\[project\]\//, "");
-  s = s.replace(/^file:\/\//, "");
-  s = s.replace(/^\/@fs\//, "/");
-  s = s.replace(/^\/@id\//, "");
+var cachedSets = /* @__PURE__ */ new Map();
+function loadAriaSampleSet(projectName) {
+  if (cachedSets.has(projectName)) return cachedSets.get(projectName);
+  let set = null;
   try {
-    s = decodeURIComponent(s);
+    const raw = fs4.readFileSync(getAriaSampleFilePath(projectName), "utf8");
+    const parsed2 = JSON.parse(raw);
+    if (parsed2.projectName === projectName && Array.isArray(parsed2.identities)) {
+      set = new Set(parsed2.identities.filter((x) => typeof x === "string"));
+    }
   } catch {
+    set = null;
   }
-  s = s.replace(/\\/g, "/");
-  if (/^\/[A-Za-z]:\//.test(s)) s = s.slice(1);
-  s = s.replace(/(^|\/)\.\//g, "$1");
-  return s;
+  cachedSets.set(projectName, set);
+  return set;
 }
-
-// ../core/src/code-reach.ts
-var MAX_CODE_REACH_FILES = 2e3;
-function executedFunctionRanges(entry) {
-  const length = entry.source?.length ?? Number.POSITIVE_INFINITY;
-  const out = [];
-  entry.functions.forEach((fn, i) => {
-    const whole = fn.ranges[0];
-    if (!whole || whole.count <= 0) return;
-    const topLevel = whole.startOffset === 0 && (whole.endOffset >= length || i === 0 && fn.functionName === "");
-    if (topLevel) return;
-    out.push({ start: whole.startOffset, end: whole.endOffset });
-  });
-  return out;
+function isDueForAriaSample(testInfo) {
+  const projectName = process.env.PIWI_PROJECT_NAME;
+  if (!projectName) return false;
+  const set = loadAriaSampleSet(projectName);
+  if (!set || set.size === 0) return false;
+  return set.has(
+    ariaSampleIdentity(relativeTestPath(testInfo.file, configDirFromConfig(testInfo.config)), testInfo.title)
+  );
 }
-function executedFunctionOffsets(entry) {
-  return executedFunctionRanges(entry).map((range) => range.start);
+
+// src/internal/capture/quiet-capture.ts
+var import_node_module = require("module");
+var path8 = __toESM(require("path"));
+
+// src/internal/support/reporter-version.ts
+var fs5 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var CANDIDATE_OFFSETS = ["..", "../../.."];
+function findOwnPackageJson(fromDir) {
+  for (const offset of CANDIDATE_OFFSETS) {
+    try {
+      const pkgPath = path7.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const { name, version } = pkg;
+      if (name === "@piwitests/reporter" && typeof version === "string")
+        return { version, root: path7.dirname(pkgPath) };
+    } catch {
+    }
+  }
+  return void 0;
 }
-function scriptRan(entry) {
-  return executedFunctionOffsets(entry).length > 0;
+
+// src/internal/capture/quiet-capture.ts
+var BOXED_PREFIX_EXPORTS = [
+  [
+    "playwright-core/lib/coreBundle",
+    (mod) => mod?.utils?.setBoxedStackPrefixes
+  ],
+  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
+];
+var boxing;
+var resolvedPlaywrightPackageJson;
+function resolvePlaywrightPackageJson() {
+  if (resolvedPlaywrightPackageJson !== void 0) return resolvedPlaywrightPackageJson;
+  try {
+    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
+    resolvedPlaywrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
+  } catch {
+    resolvedPlaywrightPackageJson = null;
+  }
+  return resolvedPlaywrightPackageJson;
 }
-function reachedSources(entry, map) {
-  const ranges = executedFunctionRanges(entry);
-  const reached = /* @__PURE__ */ new Set();
-  if (!ranges.length || entry.source === void 0) return reached;
-  const starts = lineStarts(entry.source);
-  for (const range of ranges) {
-    const start = offsetToPosition(starts, range.start);
-    const source = map.sourceAt(start.line, start.column);
-    if (source === null || reached.has(source)) continue;
-    if (map.mapsBetween(source, start, offsetToPosition(starts, range.end))) reached.add(source);
+function resolveBoxing() {
+  try {
+    const root = findOwnPackageJson(__dirname)?.root;
+    if (!root) return null;
+    const playwrightPackageJson = resolvePlaywrightPackageJson();
+    if (!playwrightPackageJson) return null;
+    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
+    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
+      let set;
+      try {
+        set = pick(requireFromPlaywright(moduleId));
+      } catch {
+        continue;
+      }
+      if (typeof set !== "function") continue;
+      return {
+        set,
+        prefixes: [path8.dirname(playwrightPackageJson), path8.join(root, "dist") + path8.sep]
+      };
+    }
+  } catch {
   }
-  return reached;
+  return null;
 }
-function finalizeCodeReach(files) {
-  const out = /* @__PURE__ */ new Set();
-  for (const raw of files) {
-    const file = normalizeCoveragePath(raw);
-    if (file !== null) out.add(file);
+function boxCaptureFrames(extraPrefixes = []) {
+  const first = boxing === void 0;
+  if (first) boxing = resolveBoxing();
+  if (!boxing) return;
+  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
+  if (!first && added.length === 0) return;
+  boxing.prefixes.push(...added);
+  try {
+    boxing.set([...boxing.prefixes]);
+  } catch {
   }
-  return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
+}
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
+function internalCall(owner, run) {
+  const wrap = owner?._wrapApiCall;
+  if (typeof wrap !== "function") return run();
+  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
 }
 
 // src/internal/capture/code-reach.ts
+var crypto2 = __toESM(require("crypto"));
+var fs6 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
 var MAX_MAP_BYTES = 20 * 1024 * 1024;
 var MAP_TIMEOUT_MS = 5e3;
 var SOURCE_EXTENSIONS = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|marko|html?)$/i;
 var REPLAYED_SCRIPT = /^(?:about|rsc):/i;
+var NEVER_REACHED = /\/node_modules\/|\/@vite\//;
 var BUILD_DIRS = /(?:^|\/)(?:dist|build|out|\.output|\.next|\.nuxt|\.svelte-kit|public|static|wwwroot)\//;
-var MAX_CACHED_SCRIPTS = 500;
+var MAX_CACHED_SCRIPTS = 4e3;
 var LatestByUrl = class {
   constructor() {
     this.entries = /* @__PURE__ */ new Map();
@@ -4322,13 +4620,37 @@ function repositoryRoot(from) {
     }).trim();
   } catch {
   }
-  cachedRepoRoot = { from, root: path10.resolve(root) };
+  cachedRepoRoot = { from, root: path9.resolve(root) };
   return cachedRepoRoot.root;
 }
 function codeReachRoots(configDir, configured) {
   const repoRoot = repositoryRoot(configDir);
-  const roots = configured?.length ? configured.map((r) => path10.resolve(configDir, r)) : [configDir];
-  return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], repoRoot };
+  const resolve3 = (dirs) => (Array.isArray(dirs) ? dirs : dirs ? [dirs] : []).filter(Boolean).map((r) => path9.resolve(configDir, r));
+  const global = Array.isArray(configured) ? resolve3(configured) : resolve3(configured?.["*"]);
+  const byOrigin = /* @__PURE__ */ new Map();
+  if (configured && !Array.isArray(configured)) {
+    for (const [key, dirs] of Object.entries(configured)) {
+      const origin = key === "*" ? null : originOf2(key);
+      const resolved = resolve3(dirs);
+      if (origin && resolved.length) byOrigin.set(origin, resolved);
+    }
+  }
+  const roots = global.length ? global : [configDir];
+  return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], byOrigin, repoRoot };
+}
+function originOf2(url) {
+  if (!url) return null;
+  try {
+    const origin = new URL(url).origin;
+    return origin === "null" ? null : origin;
+  } catch {
+    return null;
+  }
+}
+function scriptRoots(roots, scriptUrl, pageUrl) {
+  if (!roots.byOrigin?.size) return roots.roots;
+  const own = roots.byOrigin.get(originOf2(scriptUrl) ?? "") ?? roots.byOrigin.get(originOf2(pageUrl) ?? "");
+  return own ? [.../* @__PURE__ */ new Set([...own, ...roots.roots])] : roots.roots;
 }
 function isFile(file) {
   try {
@@ -4340,10 +4662,10 @@ function isFile(file) {
 function resolveSourcePath(source, roots) {
   const normalized = normalizeSourcePath(source);
   if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
-  if (path10.isAbsolute(normalized) && isFile(normalized)) return path10.resolve(normalized);
-  const relative9 = normalized.replace(/^\/+/, "");
+  if (path9.isAbsolute(normalized) && isFile(normalized)) return path9.resolve(normalized);
+  const relative7 = normalized.replace(/^\/+/, "");
   for (const root of roots) {
-    const candidate = path10.resolve(root, relative9);
+    const candidate = path9.resolve(root, relative7);
     if (isFile(candidate)) return candidate;
   }
   return null;
@@ -4375,7 +4697,7 @@ function fileForUrl(url, roots, bases) {
   return file;
 }
 function relativeToRepo(file, repoRoot) {
-  return path10.relative(repoRoot, file).split(path10.sep).join("/");
+  return path9.relative(repoRoot, file).split(path9.sep).join("/");
 }
 function scriptVersion(entry) {
   return entry.hash ?? crypto2.createHash("sha1").update(entry.source ?? "").digest("hex");
@@ -4412,50 +4734,96 @@ async function resolveScript(entry, roots, bases, fetchMap) {
   const version = scriptVersion(entry);
   const cached = scriptCache.get(entry.url, version);
   if (cached) return cached;
-  const file = fileForUrl(entry.url, roots.roots, bases);
+  const file = fileForUrl(entry.url, roots, bases);
   const lookup = await loadMap(entry, fetchMap);
   let resolution;
-  if (file) resolution = { kind: "file", file, lookup, source: entry.source };
-  else resolution = lookup ? { kind: "map", lookup, files: [], source: entry.source } : { kind: "none" };
-  if (entry.source !== void 0) scriptCache.set(entry.url, version, resolution);
+  const text = entry.source === void 0 ? void 0 : scriptText(entry.source);
+  if (file) resolution = { kind: "file", file, lookup, text };
+  else resolution = lookup ? { kind: "map", lookup, files: [], text } : { kind: "none" };
+  if (text) scriptCache.set(entry.url, version, resolution);
   return resolution;
 }
-function withSource(entry, resolution) {
-  if (entry.source !== void 0 || resolution.source === void 0) return entry;
-  return { ...entry, source: resolution.source };
+function textOf2(entry, resolution) {
+  return resolution.text ?? (entry.source === void 0 ? void 0 : scriptText(entry.source));
+}
+async function resolveCodeReach(entries, roots, fetchMap, pageUrl) {
+  return finalizeCodeReach((await resolveReach(entries, roots, fetchMap, pageUrl)).keys());
+}
+async function resolveCodeReachFunctions(entries, roots, fetchMap, pageUrl, options = {}) {
+  return resolveFunctions(entries, roots, fetchMap, pageUrl, options.known === true);
+}
+async function resolveReach(entries, roots, fetchMap, pageUrl) {
+  return (await resolveFunctions(entries, roots, fetchMap, pageUrl, false)).reached;
 }
-async function resolveCodeReach(entries, roots, fetchMap) {
-  const files = /* @__PURE__ */ new Set();
+var knownCache = new LatestByUrl();
+async function resolveFunctions(entries, roots, fetchMap, pageUrl, withKnown) {
+  const files = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  const addTo = (into, file, functions) => {
+    const path13 = relativeToRepo(file, roots.repoRoot);
+    const listed = into.get(path13);
+    if (listed) listed.push(...functions);
+    else into.set(path13, [...functions]);
+  };
+  const add = (file, functions) => addTo(files, file, functions);
   const bases = viteBases(entries);
   const scripts = entries.filter((entry) => entry.url && entry.functions?.length && !REPLAYED_SCRIPT.test(entry.url));
-  const known = scripts.map((entry) => scriptCache.get(entry.url, scriptVersion(entry)));
+  const cached = scripts.map((entry) => scriptCache.get(entry.url, scriptVersion(entry)));
   for (const [i, covered] of scripts.entries()) {
-    const resolution = known[i] ?? await resolveScript(covered, roots, bases, fetchMap);
+    const dirs = scriptRoots(roots, covered.url, covered.pageUrl ?? pageUrl);
+    const resolution = cached[i] ?? await resolveScript(covered, dirs, bases, fetchMap);
+    const mapFile = (resolved, index) => {
+      if (resolved.files[index] === void 0) {
+        const source = resolved.lookup.sources[index] ?? "";
+        let absolute = resolveSourcePath(source, dirs);
+        if (!absolute && !/^[a-z][\w+.-]*:/i.test(source)) {
+          try {
+            absolute = fileForUrl(new URL(source, covered.url).href, dirs, bases);
+          } catch {
+            absolute = null;
+          }
+        }
+        resolved.files[index] = absolute;
+      }
+      return resolved.files[index] ?? null;
+    };
     if (resolution.kind === "file") {
-      const entry = withSource(covered, resolution);
-      const ran = resolution.lookup ? reachedSources(entry, resolution.lookup).size > 0 : scriptRan(entry);
-      if (resolution.file && ran) files.add(relativeToRepo(resolution.file, roots.repoRoot));
+      if (!resolution.file) continue;
+      const text = textOf2(covered, resolution);
+      if (resolution.lookup) {
+        const reached = reachedFunctionLines(covered, resolution.lookup, text);
+        if (reached.size > 0) add(resolution.file, [...reached.values()].flat());
+      } else if (scriptRan(covered, text)) {
+        add(resolution.file, reachedFunctionLines(covered, null, text).get(-1) ?? []);
+      }
     } else if (resolution.kind === "map") {
-      const entry = withSource(covered, resolution);
-      for (const index of reachedSources(entry, resolution.lookup)) {
-        if (resolution.files[index] === void 0) {
-          const source = resolution.lookup.sources[index] ?? "";
-          let absolute = resolveSourcePath(source, roots.roots);
-          if (!absolute && !/^[a-z][\w+.-]*:/i.test(source)) {
-            try {
-              absolute = fileForUrl(new URL(source, entry.url).href, roots.roots, bases);
-            } catch {
-              absolute = null;
-            }
-          }
-          resolution.files[index] = absolute;
+      for (const [index, functions] of reachedFunctionLines(covered, resolution.lookup, textOf2(covered, resolution))) {
+        const file = mapFile(resolution, index);
+        if (file) add(file, functions);
+      }
+    }
+    if (!withKnown || resolution.kind === "none") continue;
+    const version = scriptVersion(covered);
+    let listed = knownCache.get(covered.url, version);
+    if (!listed || listed.count < covered.functions.length) {
+      const byFile = /* @__PURE__ */ new Map();
+      const text = textOf2(covered, resolution);
+      if (resolution.kind === "file" && resolution.file) {
+        const lines = knownFunctionLines(covered, resolution.lookup, text);
+        const all = resolution.lookup ? [...lines.values()].flat() : lines.get(-1) ?? [];
+        if (all.length > 0) byFile.set(resolution.file, all);
+      } else if (resolution.kind === "map") {
+        for (const [index, functions] of knownFunctionLines(covered, resolution.lookup, text)) {
+          const file = mapFile(resolution, index);
+          if (file) byFile.set(file, [...byFile.get(file) ?? [], ...functions]);
         }
-        const file = resolution.files[index];
-        if (file) files.add(relativeToRepo(file, roots.repoRoot));
       }
+      listed = { count: covered.functions.length, files: byFile };
+      knownCache.set(covered.url, version, listed);
     }
+    for (const [file, functions] of listed.files) addTo(known, file, functions);
   }
-  return finalizeCodeReach(files);
+  return { reached: files, known };
 }
 function pageMapFetcher(page) {
   return async (url) => {
@@ -4479,12 +4847,57 @@ function isChromiumPage(page) {
   }
 }
 var captures = /* @__PURE__ */ new WeakMap();
+var MARK_WORLD = "piwi-code-reach";
+var MARK_FUNCTION = "piwiCodeReachMark";
+var MARK_SOURCE = `addEventListener('beforeunload', function ${MARK_FUNCTION}() {});`;
+var markedDocuments = /* @__PURE__ */ new WeakMap();
+function marksOf(page) {
+  let marks = markedDocuments.get(page);
+  if (!marks) {
+    marks = /* @__PURE__ */ new Set();
+    markedDocuments.set(page, marks);
+  }
+  return marks;
+}
+async function markCurrentDocument(page, cdp) {
+  try {
+    const { frameTree } = await internalCall(page, () => cdp.send("Page.getFrameTree"));
+    const marks = marksOf(page);
+    if (marks.has(frameTree.frame.loaderId)) return;
+    const world = await internalCall(
+      page,
+      () => cdp.send("Page.createIsolatedWorld", { frameId: frameTree.frame.id, worldName: MARK_WORLD })
+    );
+    await internalCall(
+      page,
+      () => cdp.send("Runtime.evaluate", { expression: MARK_SOURCE, contextId: world.executionContextId })
+    );
+    marks.add(frameTree.frame.loaderId);
+  } catch {
+  }
+}
+function onPaused(page, capture, event) {
+  const leaving = event.reason === "EventListener" && event.data?.eventName === "listener:beforeunload" && (event.callFrames?.[0]?.functionName ?? MARK_FUNCTION) === MARK_FUNCTION;
+  const read = leaving ? readCoverage(page, capture.cdp) : null;
+  if (read) {
+    const merging = read.then(
+      (coverage) => mergeCoverageRead(capture.ran, capture.scripts, coverage, capture.keepIdle)
+    );
+    capture.reading.add(merging);
+    void merging.finally(() => capture.reading.delete(merging));
+  }
+  void (read ?? Promise.resolve()).finally(() => {
+    internalCall(page, () => capture.cdp.send("Debugger.resume")).catch(() => {
+    });
+  });
+}
 function versionKey(url, hash) {
   return `${hash} ${url}`;
 }
 function onScriptParsed(page, capture, event) {
   if (!event.url || REPLAYED_SCRIPT.test(event.url)) return;
-  capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash });
+  capture.scripts.set(event.scriptId, { url: event.url, hash: event.hash, pageUrl: capture.pageUrl });
+  if (NEVER_REACHED.test(event.url)) return;
   const key = versionKey(event.url, event.hash);
   if (capture.sources.has(key) || scriptCache.get(event.url, event.hash)) return;
   const source = internalCall(
@@ -4499,6 +4912,44 @@ function onScriptParsed(page, capture, event) {
   );
   capture.sources.set(key, source);
 }
+var READ_WAIT_MS = 5e3;
+function readCoverage(page, cdp) {
+  let timer;
+  const late = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3([]), READ_WAIT_MS);
+  });
+  const taken = internalCall(page, () => cdp.send("Profiler.takePreciseCoverage")).then(
+    (answer) => answer.result,
+    () => []
+  );
+  return Promise.race([taken, late]).finally(() => clearTimeout(timer));
+}
+function mergeCoverageRead(ran, scripts, read, keepIdle = true) {
+  for (const covered of read) {
+    const script = scripts.get(covered.scriptId);
+    if (!script) continue;
+    const key = versionKey(script.url, script.hash);
+    let known = ran.get(key);
+    if (!known) {
+      known = { script, functions: [], byRange: /* @__PURE__ */ new Map() };
+      ran.set(key, known);
+    }
+    for (const fn of covered.functions) {
+      const whole = fn.ranges[0];
+      if (!whole) continue;
+      if (!keepIdle && whole.count <= 0) continue;
+      const range = `${whole.startOffset}:${whole.endOffset}`;
+      const seen = known.byRange.get(range);
+      if (seen) {
+        if (whole.count > 0 && seen.ranges[0].count <= 0) seen.ranges[0].count = whole.count;
+        continue;
+      }
+      const copy = { ...fn, ranges: fn.ranges.map((r) => ({ ...r })) };
+      known.byRange.set(range, copy);
+      known.functions.push(copy);
+    }
+  }
+}
 async function detach(page, cdp) {
   try {
     await internalCall(page, () => cdp.detach());
@@ -4510,21 +4961,35 @@ async function startCodeReach(page) {
   let cdp = null;
   try {
     cdp = await internalCall(page, () => page.context().newCDPSession(page));
-    const capture = { cdp, scripts: /* @__PURE__ */ new Map(), sources: /* @__PURE__ */ new Map() };
+    const capture = {
+      cdp,
+      scripts: /* @__PURE__ */ new Map(),
+      sources: /* @__PURE__ */ new Map(),
+      ran: /* @__PURE__ */ new Map(),
+      keepIdle: browserFunctionsInWorker(),
+      reading: /* @__PURE__ */ new Set(),
+      pageUrl: page.url()
+    };
+    const marks = marksOf(page);
     cdp.on("Debugger.scriptParsed", (event) => onScriptParsed(page, capture, event));
-    cdp.on("Debugger.paused", () => {
-      internalCall(page, () => capture.cdp.send("Debugger.resume")).catch(() => {
-      });
+    cdp.on("Debugger.paused", (event) => onPaused(page, capture, event));
+    cdp.on("Page.frameNavigated", (event) => {
+      if (event.frame.parentId) return;
+      marks.add(event.frame.loaderId);
+      capture.pageUrl = event.frame.url;
     });
     await internalCall(
       page,
       () => Promise.all([
         capture.cdp.send("Debugger.enable"),
-        capture.cdp.send("Debugger.setSkipAllPauses", { skip: true }),
         capture.cdp.send("Profiler.enable"),
-        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false })
+        capture.cdp.send("Profiler.startPreciseCoverage", { callCount: false, detailed: false }),
+        capture.cdp.send("Page.enable"),
+        capture.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: MARK_SOURCE, worldName: MARK_WORLD }),
+        capture.cdp.send("DOMDebugger.setEventListenerBreakpoint", { eventName: "beforeunload" })
       ])
     );
+    await markCurrentDocument(page, capture.cdp);
     captures.set(page, capture);
     return true;
   } catch {
@@ -4538,17 +5003,17 @@ async function stopCodeReach(page) {
   captures.delete(page);
   const { cdp } = capture;
   try {
-    const coverage = await internalCall(page, async () => {
+    const last = await internalCall(page, async () => {
       const taken = await cdp.send("Profiler.takePreciseCoverage");
       await cdp.send("Profiler.stopPreciseCoverage");
-      return taken;
+      return taken.result;
     });
+    await Promise.all(capture.reading);
+    mergeCoverageRead(capture.ran, capture.scripts, last, capture.keepIdle);
     const entries = [];
-    for (const script of coverage.result) {
-      const parsed2 = capture.scripts.get(script.scriptId);
-      if (!parsed2) continue;
-      const entry = { url: parsed2.url, hash: parsed2.hash, functions: script.functions };
-      const source = await capture.sources.get(versionKey(parsed2.url, parsed2.hash));
+    for (const [key, { script, functions }] of capture.ran) {
+      const entry = { url: script.url, hash: script.hash, functions, pageUrl: script.pageUrl };
+      const source = await capture.sources.get(key);
       if (source != null) entry.source = source;
       entries.push(entry);
     }
@@ -4562,7 +5027,7 @@ async function stopCodeReach(page) {
 
 // src/internal/capture/resource-ledger.ts
 var fs8 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 var import_node_module2 = require("module");
 
 // src/internal/capture/worker-metrics.ts
@@ -4570,7 +5035,7 @@ var import_node_perf_hooks = require("perf_hooks");
 
 // src/internal/support/system-readers.ts
 var fs7 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var CLK_TCK = 100;
 function readText(file) {
   try {
@@ -4656,7 +5121,7 @@ var ProcFs = class {
   }
   /** Whether this looks like a Linux `/proc` at all. */
   available() {
-    return fs7.existsSync(path11.join(this.root, "stat"));
+    return fs7.existsSync(path10.join(this.root, "stat"));
   }
   /** Every process, keyed by pid. */
   table() {
@@ -4669,32 +5134,32 @@ var ProcFs = class {
     }
     for (const name of names) {
       if (!/^\d+$/.test(name)) continue;
-      const text = readText(path11.join(this.root, name, "stat"));
+      const text = readText(path10.join(this.root, name, "stat"));
       const stat = text ? parseProcStat(Number(name), text) : null;
       if (stat) out.set(stat.pid, stat);
     }
     return out;
   }
   stat(pid) {
-    const text = readText(path11.join(this.root, String(pid), "stat"));
+    const text = readText(path10.join(this.root, String(pid), "stat"));
     return text ? parseProcStat(pid, text) : null;
   }
   runWaitMs(pid) {
-    const text = readText(path11.join(this.root, String(pid), "schedstat"));
+    const text = readText(path10.join(this.root, String(pid), "schedstat"));
     return text ? parseSchedstat(text) : null;
   }
   cmdline(pid) {
-    return (readText(path11.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
+    return (readText(path10.join(this.root, String(pid), "cmdline")) ?? "").split("\0").join(" ").trim();
   }
   /** A field of `/proc/<pid>/status`, in kB: `VmRSS`, `VmHWM`. */
   statusKb(pid, key) {
-    const text = readText(path11.join(this.root, String(pid), "status"));
+    const text = readText(path10.join(this.root, String(pid), "status"));
     return text ? parseKbField(text, key) : null;
   }
   /** Proportional set size: shared pages split between the processes sharing them, so a sum counts them once. */
   async pssKb(pid) {
     try {
-      return parseKbField(await fs7.promises.readFile(path11.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
+      return parseKbField(await fs7.promises.readFile(path10.join(this.root, String(pid), "smaps_rollup"), "utf8"), "Pss");
     } catch {
       return null;
     }
@@ -4702,29 +5167,29 @@ var ProcFs = class {
   /** Reset a process's peak RSS (`VmHWM`) to its current RSS. */
   resetPeakRss(pid) {
     try {
-      fs7.writeFileSync(path11.join(this.root, String(pid), "clear_refs"), "5");
+      fs7.writeFileSync(path10.join(this.root, String(pid), "clear_refs"), "5");
       return true;
     } catch {
       return false;
     }
   }
   cpuTicks() {
-    const text = readText(path11.join(this.root, "stat"));
+    const text = readText(path10.join(this.root, "stat"));
     return text ? parseCpuTicks(text) : null;
   }
   /** Total stall time of a resource's pressure file, in µs. */
   pressureUs(resource) {
-    const text = readText(path11.join(this.root, "pressure", resource));
+    const text = readText(path10.join(this.root, "pressure", resource));
     return text ? parsePsiTotal(text) : null;
   }
   memAvailableKb() {
-    const text = readText(path11.join(this.root, "meminfo"));
+    const text = readText(path10.join(this.root, "meminfo"));
     return text ? parseKbField(text, "MemAvailable") : null;
   }
   /** Open file descriptors of a process. */
   fdCount(pid) {
     try {
-      return fs7.readdirSync(path11.join(this.root, String(pid), "fd")).length;
+      return fs7.readdirSync(path10.join(this.root, String(pid), "fd")).length;
     } catch {
       return null;
     }
@@ -4886,10 +5351,10 @@ var PAGE_READ_TIMEOUT_MS = 1e3;
 var HOOK_PHASES = /* @__PURE__ */ new Set(["beforeAll", "afterAll", "beforeEach", "afterEach"]);
 var KIND_ORDER = { browser: 0, context: 1, page: 2, request: 3 };
 function relativePath(file) {
-  return path12.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path12.sep).join("/");
+  return path11.relative(process.cwd(), file.replace(/^file:\/\//, "")).split(path11.sep).join("/");
 }
 function isLibraryFile(file) {
-  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path12.sep}node_modules${path12.sep}`) || file.includes("/node_modules/") || file === __filename;
+  return file.startsWith("node:") || file.startsWith("internal/") || file.includes(`${path11.sep}node_modules${path11.sep}`) || file.includes("/node_modules/") || file === __filename;
 }
 function userSite(stack) {
   for (const line of (stack ?? "").split("\n").slice(1)) {
@@ -4937,7 +5402,7 @@ function playwrightTestInfoSource() {
   try {
     const packageJson = resolvePlaywrightPackageJson();
     if (!packageJson) return () => null;
-    const globals = (0, import_node_module2.createRequire)(packageJson)(path12.join(path12.dirname(packageJson), "lib", "globals.js"));
+    const globals = (0, import_node_module2.createRequire)(packageJson)(path11.join(path11.dirname(packageJson), "lib", "globals.js"));
     const read = globals.currentTestInfo;
     if (typeof read !== "function") return () => null;
     return () => {
@@ -5721,52 +6186,87 @@ function createSink() {
     userPick: null,
     pause: null,
     locatorPages: new LocatorPageLog(),
-    codeReach: null,
+    codeReach: { sessions: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() },
     serverCoverage: /* @__PURE__ */ new Map(),
     baseURL: null
   };
 }
-function maybeStartCodeReach(page) {
+var MAX_CODE_REACH_PAGES = 16;
+var CODE_REACH_START_WAIT_MS = 2e3;
+function maybeStartCodeReach(page, alreadyOpen = false) {
   const sink = currentSink;
-  if (!sink || !browserCoverageInWorker()) return Promise.resolve(false);
-  if (sink.codeReach) return sink.codeReach.page === page ? sink.codeReach.started : Promise.resolve(false);
+  if (!sink || !browserCoverageInWorker() || isPageClosed(page)) return Promise.resolve(false);
+  const known = sink.codeReach.sessions.get(page);
+  if (known) return known.started;
+  if (alreadyOpen) {
+    let recording = 0;
+    for (const [other, session] of sink.codeReach.sessions) if (!session.stopped && !isPageClosed(other)) recording++;
+    if (recording >= MAX_CODE_REACH_PAGES) return Promise.resolve(false);
+  }
   const started = startCodeReach(page);
-  sink.codeReach = { page, started, stopped: false, files: null };
+  sink.codeReach.sessions.set(page, { started, stopped: false });
   return started;
 }
+async function startCodeReachOnOpenPages() {
+  if (!browserCoverageInWorker() || OPEN_PAGES.size === 0) return;
+  const started = Promise.all([...OPEN_PAGES].map((page) => maybeStartCodeReach(page, true)));
+  await Promise.race([started, new Promise((resolve3) => setTimeout(resolve3, CODE_REACH_START_WAIT_MS).unref())]);
+}
 function configuredCodeReachRoots() {
   const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
   if (!raw) return null;
+  const dirs = (value) => (Array.isArray(value) ? value : [value]).filter((r) => typeof r === "string" && r !== "");
   try {
     const parsed2 = JSON.parse(raw);
-    if (Array.isArray(parsed2)) return parsed2.filter((r) => typeof r === "string" && r !== "");
+    if (Array.isArray(parsed2)) return dirs(parsed2);
+    if (parsed2 && typeof parsed2 === "object") {
+      return Object.fromEntries(Object.entries(parsed2).map(([origin, value]) => [origin, dirs(value)]));
+    }
   } catch {
   }
-  return raw.split(path13.delimiter).filter(Boolean);
+  return raw.split(path12.delimiter).filter(Boolean);
 }
 async function stopSinkCodeReach(sink, closing) {
-  const session = sink.codeReach;
-  if (!session || session.stopped) return;
-  if (closing && closing.page !== session.page && (!closing.context || pageContext(session.page) !== closing.context)) {
-    return;
+  const stopping = [];
+  const underway = [];
+  for (const [page, session] of sink.codeReach.sessions) {
+    if (session.stopped) {
+      if (!closing && session.stopping) underway.push(session.stopping);
+      continue;
+    }
+    if (closing && closing.page !== page && (!closing.context || pageContext(page) !== closing.context)) continue;
+    session.stopped = true;
+    stopping.push([page, session]);
+  }
+  if (stopping.length > 0) {
+    const info = sink.testInfo;
+    const roots = codeReachRoots(configDirFromConfig(info?.config), configuredCodeReachRoots());
+    for (const [page, session] of stopping) {
+      session.stopping = stopPageCodeReach(sink, page, session, roots);
+      underway.push(session.stopping);
+    }
   }
-  session.stopped = true;
+  await Promise.all(underway);
+}
+async function stopPageCodeReach(sink, page, session, roots) {
   try {
-    if (!await session.started || isPageClosed(session.page)) return;
-    const entries = await stopCodeReach(session.page);
+    if (!await session.started || isPageClosed(page)) return;
+    const entries = await stopCodeReach(page);
     if (!entries) return;
-    const info = sink.testInfo;
-    const configFile = info?.config.configFile;
-    const configDir = configFile ? path13.dirname(configFile) : info?.config.rootDir ?? process.cwd();
-    session.files = await resolveCodeReach(
-      entries,
-      codeReachRoots(configDir, configuredCodeReachRoots()),
-      pageMapFetcher(session.page)
-    );
+    const { reached, known } = await resolveCodeReachFunctions(entries, roots, pageMapFetcher(page), page.url(), {
+      known: browserFunctionsInWorker()
+    });
+    for (const [file, functions] of reached) {
+      sink.codeReach.files.set(file, [...sink.codeReach.files.get(file) ?? [], ...functions]);
+    }
+    for (const [file, functions] of known) {
+      sink.codeReach.known.set(file, [...sink.codeReach.known.get(file) ?? [], ...functions]);
+    }
   } catch {
   }
 }
 var currentSink = null;
+var KNOWN_FUNCTIONS_SENT = /* @__PURE__ */ new Map();
 var PENDING_PROBES = /* @__PURE__ */ new Set();
 async function drainPendingProbes(capMs) {
   if (PENDING_PROBES.size === 0) return;
@@ -5882,8 +6382,8 @@ function buildPageState(raw, cookies, interaction) {
     length: typeof e.length === "number" ? e.length : 0
   }));
   return {
-    url: raw.url,
-    hash: raw.hash || null,
+    url: raw.url.split("#")[0],
+    hash: raw.hash ? maskUrlFragment(raw.hash) : null,
     historyState: historyState || null,
     localStorage: capStorage(raw.localStorage),
     sessionStorage: capStorage(raw.sessionStorage),
@@ -6063,6 +6563,7 @@ async function maybeOpenPicker(sink, closing) {
   applyPickToSnapshots(sink.capturedLocators, pick);
 }
 var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
+var OPEN_PAGES = /* @__PURE__ */ new Set();
 var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
 var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
@@ -6343,6 +6844,10 @@ var CANCELLED_REQUEST = /^net::ERR_ABORTED$|^NS_BINDING_ABORTED$|^NS_ERROR_ABORT
 function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
+  if (typeof page.once === "function") {
+    OPEN_PAGES.add(page);
+    page.once("close", () => OPEN_PAGES.delete(page));
+  }
   void maybeStartCodeReach(page);
   observeOwnApiRequests(page);
   const probeSink = currentSink;
@@ -6679,10 +7184,24 @@ async function flushSink(sink, testInfo) {
     });
   }
   await stopSinkCodeReach(sink);
-  if (sink.codeReach?.files?.length) {
+  if (sink.codeReach.files.size > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.codeReach, {
       contentType: "application/json",
-      body: Buffer.from(JSON.stringify(sink.codeReach.files))
+      body: Buffer.from(JSON.stringify(finalizeCodeReach(sink.codeReach.files.keys())))
+    });
+    const functions = browserFunctionsInWorker() ? browserFunctionCoverage(sink.codeReach.files) : null;
+    if (functions) {
+      await testInfo.attach(ATTACHMENT_NAMES.browserCoverage, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(functions))
+      });
+    }
+  }
+  const known = browserFunctionsInWorker() ? newKnownFunctions(sink.codeReach.known, KNOWN_FUNCTIONS_SENT) : [];
+  for (const part of known) {
+    await testInfo.attach(ATTACHMENT_NAMES.browserFunctions, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(part))
     });
   }
   if (sink.serverCoverage.size > 0) {
@@ -6881,6 +7400,7 @@ var piwiFixtures = {
         const plan = loadFlakePlan();
         const role = flakeRoleForTest(plan, {
           file: testInfo.file,
+          base: configDirFromConfig(testInfo.config),
           title: testInfo.title,
           titlePath: testInfo.titlePath,
           project: testInfo.project.name
@@ -6894,11 +7414,13 @@ var piwiFixtures = {
         sink.probeItem = probeItemForTest({
           title: testInfo.title,
           file: testInfo.file,
-          titlePath: testInfo.titlePath
+          titlePath: testInfo.titlePath,
+          base: configDirFromConfig(testInfo.config)
         });
       activeResourceLedger()?.testStarted(testInfo);
       currentSink = sink;
       try {
+        await startCodeReachOnOpenPages();
         await use();
       } finally {
         currentSink = null;
@@ -6937,6 +7459,7 @@ async function recordFlakeAttempt(flake, testInfo) {
     flakeResultLine(flake.plan, {
       role: flake.role,
       file: testInfo.file,
+      base: configDirFromConfig(testInfo.config),
       title: testInfo.title,
       project: testInfo.project.name || null,
       browserName: flake.browserName,