@piwitests/reporter 0.12.0 → 0.13.0

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

@@ -1,1041 +1,2281 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.piwiFixtures = exports.CAPTURED_ATTRS_ARG = void 0;
-exports.computeCoreVitals = computeCoreVitals;
-exports.buildPageState = buildPageState;
-exports.ariaSnapshotBestEffort = ariaSnapshotBestEffort;
-exports.probeElementAttrs = probeElementAttrs;
-exports.extendPiwiFixtures = extendPiwiFixtures;
-const node_zlib_1 = require("node:zlib");
-const locator_healing_js_1 = require("./locator-healing.js");
-const attachments_js_1 = require("./attachments.js");
-/**
- * Aggregate buffered performance entries into LCP/CLS/INP. Pure and Node-side
- * so it is unit-testable; the in-page evaluate only ships raw entry projections.
- * A null entry list means the entry type is unsupported (non-Chromium) — the
- * metric is null rather than 0 so absence is distinguishable from "no shifts".
- */
-function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
-    // The last LCP candidate is the final LCP.
-    const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
-    const lcp = lastLcp && typeof lastLcp.startTime === 'number' ? Math.round(lastLcp.startTime) : null;
-    // Simple sum over shifts without recent input. The spec's session-window
-    // grouping matters for long sessions; a test's page lifetime is short enough
-    // that the plain sum tracks it closely.
-    let cls = null;
-    if (shiftEntries) {
-        const sum = shiftEntries.reduce((acc, e) => acc + (e.hadRecentInput ? 0 : typeof e.value === 'number' ? e.value : 0), 0);
-        cls = Math.round(sum * 10000) / 10000;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal/capture/capture-fixtures.ts
+var capture_fixtures_exports = {};
+__export(capture_fixtures_exports, {
+  CAPTURED_ATTRS_ARG: () => CAPTURED_ATTRS_ARG,
+  ariaSnapshotBestEffort: () => ariaSnapshotBestEffort,
+  buildPageState: () => buildPageState,
+  computeCoreVitals: () => computeCoreVitals,
+  extendPiwiFixtures: () => extendPiwiFixtures,
+  piwiFixtures: () => piwiFixtures,
+  probeElementAttrs: () => probeElementAttrs
+});
+module.exports = __toCommonJS(capture_fixtures_exports);
+var import_node_zlib = require("zlib");
+
+// src/internal/capture/locator-healing.ts
+var path = __toESM(require("path"));
+
+// ../packages/core/src/locator-fingerprint.ts
+var PRESENT_SIMILARITY = 0.8;
+var MATCH_SIMILARITY = 0.2;
+function parseAriaCandidates(ariaSnapshot) {
+  if (!ariaSnapshot) return [];
+  const out = [];
+  for (const line of ariaSnapshot.split("\n")) {
+    const m = line.match(/^\s*-\s+([a-z]+)(?:\s+"((?:[^"\\]|\\.)*)")?/i);
+    if (!m) continue;
+    const role = m[1];
+    const name = m[2] != null ? m[2].replace(/\\(.)/g, "$1") : null;
+    if (!name && (role === "generic" || role === "group" || role === "list" || role === "paragraph")) continue;
+    const levelMatch = line.slice(m[0].length).match(/\[level=(\d+)\]/);
+    const level = levelMatch ? Number(levelMatch[1]) : null;
+    out.push({ role, name, level });
+  }
+  return out;
+}
+function textSimilarity(a, b) {
+  const tok = (s) => new Set(
+    (s ?? "").toLowerCase().split(/[^a-z0-9]+/i).filter(Boolean)
+  );
+  const sa = tok(a);
+  const sb = tok(b);
+  if (sa.size === 0 && sb.size === 0) return 1;
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let common = 0;
+  for (const t of sa) if (sb.has(t)) common++;
+  return 2 * common / (sa.size + sb.size);
+}
+function fingerprintPresent(fp, candidates) {
+  if (!fp.name) return false;
+  return candidates.some(
+    (c) => (!fp.role || c.role === fp.role) && textSimilarity(c.name, fp.name) >= PRESENT_SIMILARITY
+  );
+}
+function matchRenamedElement(fp, candidates) {
+  if (candidates.length === 0) return null;
+  const sameRole = fp.role ? candidates.filter((c) => c.role === fp.role) : candidates;
+  if (sameRole.length === 0) return null;
+  let pool = sameRole;
+  if (fp.level != null) {
+    const sameLevel = sameRole.filter((c) => c.level === fp.level);
+    if (sameLevel.length > 0) pool = sameLevel;
+  }
+  if (pool.length === 1) {
+    return { candidate: pool[0], confidence: 0.7 };
+  }
+  let best = null;
+  let bestScore = -1;
+  for (const c of pool) {
+    const s = textSimilarity(c.name, fp.name);
+    if (s > bestScore) {
+      bestScore = s;
+      best = c;
     }
-    // Worst interaction latency: max duration per interactionId, then the p98
-    // interaction when there are many (mirrors the INP definition, simplified).
-    let inp = null;
-    if (eventEntries && eventEntries.length > 0) {
-        const byInteraction = new Map();
-        for (const e of eventEntries) {
-            if (typeof e.interactionId !== 'number' || e.interactionId <= 0)
-                continue;
-            const duration = typeof e.duration === 'number' ? e.duration : 0;
-            const prev = byInteraction.get(e.interactionId) ?? 0;
-            if (duration > prev)
-                byInteraction.set(e.interactionId, duration);
-        }
-        const durations = [...byInteraction.values()].sort((a, b) => a - b);
-        if (durations.length > 0) {
-            const index = durations.length > 50 ? Math.floor(durations.length * 0.98) : durations.length - 1;
-            inp = Math.round(durations[Math.min(index, durations.length - 1)]);
-        }
+  }
+  if (best && bestScore >= MATCH_SIMILARITY) return { candidate: best, confidence: bestScore };
+  const pos = fp.rolePosition;
+  if (pos && fp.role && pos.role === fp.role && sameRole.length >= 2 && sameRole.length === pos.count) {
+    const byIndex = sameRole[pos.index];
+    if (byIndex) return { candidate: byIndex, confidence: 0.5 };
+  }
+  return null;
+}
+
+// ../packages/core/src/locator-methods.ts
+var LOCATOR_BUILDER_METHODS = [
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator"
+];
+
+// ../packages/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",
+  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-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+$/.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-)/i.test(value)) return true;
+  if (/^:r[0-9a-z]+:$/i.test(value) || /^«r[0-9a-z]+»$/i.test(value)) return true;
+  return false;
+}
+function generateAlternatives(attrs) {
+  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 = resolveAriaRole(attrs);
+  const counts = attrs.selectorCounts;
+  const isUnique = (n) => n == null || n <= 1;
+  const text = attrs.textContent ? attrs.textContent.replace(/\s+/g, " ").trim() : null;
+  const testId = attr(attrs, "data-testid");
+  if (testId && isUnique(counts?.testId)) {
+    add({
+      locator: `getByTestId('${esc(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('${role}', { name: '${esc(accessibleName)}'${levelPart} })`,
+      method: "getByRole",
+      args: withLevel({ role, name: accessibleName }),
+      score: 90
+    });
+  }
+  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
+    });
+  }
+  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
+      });
+    }
+  }
+  const placeholder = attr(attrs, "placeholder");
+  if (placeholder) {
+    add({
+      locator: `getByPlaceholder('${esc(placeholder)}')`,
+      method: "getByPlaceholder",
+      args: { placeholder },
+      score: 80
+    });
+  }
+  if (text && text.length < 80) {
+    add({
+      locator: `getByText('${esc(text)}')`,
+      method: "getByText",
+      args: { text },
+      score: 75
+    });
+  }
+  const id = attr(attrs, "id");
+  if (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
+    });
+  }
+  const name = attr(attrs, "name");
+  if (name && isUnique(counts?.name)) {
+    const selector = `[name="${escCssAttrValue(name)}"]`;
+    add({
+      locator: `locator('${esc(selector)}')`,
+      method: "locator",
+      args: { selector },
+      score: 60
+    });
+  }
+  const alt = attr(attrs, "alt");
+  if (alt) {
+    add({
+      locator: `getByAltText('${esc(alt)}')`,
+      method: "getByAltText",
+      args: { text: alt },
+      score: 60
+    });
+  }
+  const title = attr(attrs, "title");
+  if (title) {
+    add({
+      locator: `getByTitle('${esc(title)}')`,
+      method: "getByTitle",
+      args: { title },
+      score: 50
+    });
+  }
+  const hasOwnTestId = !!(testId && isUnique(counts?.testId));
+  if (role && !hasOwnTestId) {
+    const rolePart = level != null ? `'${role}', { level: ${level} }` : `'${role}'`;
+    const leafArgs = withLevel({ role });
+    let testIdAnchorDone = false;
+    let idAnchorDone = false;
+    let roleAnchorDone = false;
+    for (const anc of attrs.ancestors ?? []) {
+      if (anc.scopedRoleCount !== 1) continue;
+      if (!testIdAnchorDone && anc.testId && anc.testIdCount === 1) {
+        testIdAnchorDone = true;
+        add({
+          locator: `getByTestId('${esc(anc.testId)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorTestId: anc.testId },
+          score: 72
+        });
+      }
+      if (!idAnchorDone && anc.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)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorSelector },
+          score: 64
+        });
+      }
+      const ancestorRole = anc.role || TAG_TO_ROLE[anc.tag] || null;
+      if (!roleAnchorDone && ancestorRole && ancestorRole !== role && anc.roleCount === 1) {
+        roleAnchorDone = true;
+        add({
+          locator: `getByRole('${esc(ancestorRole)}').getByRole(${rolePart})`,
+          method: "getByRole",
+          args: { ...leafArgs, anchorRole: ancestorRole },
+          score: 55
+        });
+      }
+    }
+    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
+      });
     }
-    if (lcp === null && cls === null && inp === null)
-        return null;
-    return { lcp, cls, inp };
+  }
+  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
+      });
+    }
+  }
+  return alts.sort((a, b) => b.score - a.score);
 }
-function createSink() {
+function approximateAccessibleName(attrs) {
+  const a = attrs.attributes;
+  const ariaLabel = a["aria-label"];
+  if (ariaLabel) return ariaLabel;
+  if (attrs.textContent) return attrs.textContent;
+  const title = a["title"];
+  if (title) return title;
+  const placeholder = a["placeholder"];
+  if (placeholder) return placeholder;
+  return null;
+}
+
+// src/internal/capture/locator-healing.ts
+function dedupeSnapshotsByLocation(snaps) {
+  const lastWithElement = /* @__PURE__ */ new Map();
+  const lastAny = /* @__PURE__ */ new Map();
+  snaps.forEach((s, i) => {
+    if (!s.location) return;
+    lastAny.set(s.location, i);
+    if (s.element) lastWithElement.set(s.location, i);
+  });
+  return snaps.filter((s, i) => {
+    if (!s.location) return true;
+    return (lastWithElement.get(s.location) ?? lastAny.get(s.location)) === i;
+  });
+}
+var LOCATOR_METHODS = [...LOCATOR_BUILDER_METHODS];
+var CHAIN_METHODS = [
+  "first",
+  "nth",
+  "last",
+  "filter",
+  "and",
+  "or",
+  "locator",
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle"
+];
+var ACTION_METHODS = [
+  "click",
+  "fill",
+  "check",
+  "uncheck",
+  "selectOption",
+  "dblclick",
+  "tap",
+  "hover",
+  "press",
+  "type",
+  "pressSequentially",
+  "clear",
+  "setInputFiles",
+  "dragTo",
+  "focus",
+  "blur",
+  "scrollIntoViewIfNeeded",
+  "dispatchEvent",
+  "selectText",
+  // Not an action, but a successful waitFor proves the element resolved — the
+  // closest capture hook available for assertion-style usage of a locator.
+  "waitFor"
+];
+var LOCATOR_CREATING_CHAINS = new Set(LOCATOR_METHODS);
+function extractAccessibleName(ariaSnapshot) {
+  if (!ariaSnapshot) return null;
+  const match = ariaSnapshot.match(/- \w+ "([^"]+)"/);
+  if (match) return match[1];
+  return null;
+}
+var NAME_BASED_METHODS = /* @__PURE__ */ new Set([
+  "getByText",
+  "getByRole",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByTitle",
+  "getByAltText"
+]);
+var escAttr = (s) => s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+var SUGG_TEXT_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "heading",
+  "menuitem",
+  "tab",
+  "option",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "gridcell",
+  "treeitem",
+  "listitem",
+  "checkbox",
+  "radio",
+  "switch"
+]);
+var SUGG_FIELD_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "searchbox", "spinbutton", "slider"]);
+function failedNameAndRole(failed) {
+  if (failed.method === "getByRole") {
+    const role = typeof failed.args[0] === "string" ? failed.args[0] : null;
+    const opts = failed.args[1];
+    const name = opts && typeof opts.name === "string" ? opts.name : null;
+    const level = opts && typeof opts.level === "number" ? opts.level : null;
+    return { role, name, level };
+  }
+  const first = failed.args.find((a) => typeof a === "string");
+  return { role: null, name: typeof first === "string" ? first : null, level: null };
+}
+function renderFailing(failed) {
+  const { role, name } = failedNameAndRole(failed);
+  if (failed.method === "getByRole") {
+    return name ? `getByRole('${escAttr(role ?? "")}', { name: '${escAttr(name)}' })` : `getByRole('${escAttr(role ?? "")}')`;
+  }
+  return `${failed.method}('${escAttr(name ?? "")}')`;
+}
+function freshSuggestions(candidate, failedMethod) {
+  const out = [];
+  const role = candidate.role;
+  const name = candidate.name;
+  const push = (s) => {
+    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)}')`;
+  if (failedMethod === "getByText" && SUGG_TEXT_ROLES.has(role)) push(textLoc);
+  if (failedMethod === "getByLabel" && SUGG_FIELD_ROLES.has(role)) push(labelLoc);
+  push(roleLoc);
+  if (SUGG_TEXT_ROLES.has(role)) push(textLoc);
+  else if (SUGG_FIELD_ROLES.has(role)) push(labelLoc);
+  return out;
+}
+function suggestLocatorsFromAria(failed, ariaSnapshot) {
+  if (!ariaSnapshot || !NAME_BASED_METHODS.has(failed.method)) return null;
+  const { role, name, level } = failedNameAndRole(failed);
+  if (!name) return null;
+  const candidates = parseAriaCandidates(ariaSnapshot);
+  if (candidates.length === 0) return null;
+  const fingerprint = { role, name, level };
+  if (fingerprintPresent(fingerprint, candidates)) return null;
+  const best = matchRenamedElement(fingerprint, candidates)?.candidate;
+  if (!best || !best.name) return null;
+  const suggestions = freshSuggestions({ role: best.role, name: best.name, level: best.level }, failed.method);
+  if (suggestions.length === 0) return null;
+  return { failing: renderFailing(failed), suggestions };
+}
+function captureCallerLocation(stack = new Error().stack ?? "") {
+  const lines = stack.split("\n");
+  let prevWasCaptureModule = false;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("at")) continue;
+    const m = line.match(/^at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+    if (!m) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    let file = m[2];
+    if (!file || file.startsWith("node:")) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    file = file.replace(/^file:\/\/\/?/, "");
+    if (!/\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    if (/[\\/]locator-healing\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = true;
+      continue;
+    }
+    if (prevWasCaptureModule && /[\\/](?:capture-)?fixtures\.[a-z]+$/i.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    if (/[\\/]node_modules[\\/]/.test(file)) {
+      prevWasCaptureModule = false;
+      continue;
+    }
+    let rel = file;
+    try {
+      rel = path.relative(process.cwd(), file);
+    } catch {
+    }
+    rel = rel.split(path.sep).join("/");
+    if (rel.startsWith("./")) rel = rel.slice(2);
+    return `${rel}:${m[3]}:${m[4]}`;
+  }
+  return null;
+}
+
+// src/internal/capture/attachments.ts
+var ATTACHMENT_NAMES = {
+  locators: "piwi-locators",
+  ariaSnapshot: "piwi-aria-snapshot",
+  console: "piwi-console",
+  network: "piwi-network",
+  webVitals: "piwi-web-vitals",
+  locatorSuggestion: "piwi-locator-suggestion",
+  pageState: "piwi-page-state",
+  userPick: "piwi-user-pick"
+};
+var INTERNAL_ATTACHMENT_NAMES = new Set(Object.values(ATTACHMENT_NAMES));
+var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
+var USER_PICK_ANNOTATION = ATTACHMENT_NAMES.userPick;
+
+// src/internal/capture/inspect-on-failure.ts
+function isCi(ci) {
+  return ci !== void 0 && ci !== "" && ci !== "false";
+}
+function shouldInspectOnFailure(gate) {
+  if (gate.enabled !== "true") return false;
+  if (isCi(gate.ci)) return false;
+  if (gate.headless !== false) return false;
+  if (gate.status !== "failed" && gate.status !== "timedOut") return false;
+  if (gate.status === gate.expectedStatus) return false;
+  return gate.retry >= gate.retries;
+}
+function environmentalSkipReason(gate) {
+  if (gate.enabled !== "true") return null;
+  if (gate.status !== "failed" && gate.status !== "timedOut") return null;
+  if (gate.status === gate.expectedStatus) return null;
+  if (isCi(gate.ci)) return "running under CI \u2014 this is a headed, local-only feature";
+  if (gate.headless !== false) {
+    return "the browser is headless \u2014 re-run with --headed (or set use: { headless: false })";
+  }
+  return null;
+}
+function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT_ON_FAIL) {
+  const use = testInfo.project?.use ?? {};
+  return {
+    enabled,
+    ci: process.env.CI,
+    status: testInfo.status,
+    expectedStatus: testInfo.expectedStatus,
+    headless: use.headless,
+    retry: testInfo.retry,
+    retries: testInfo.project?.retries ?? 0
+  };
+}
+
+// src/internal/capture/pick-on-failure.ts
+var path2 = __toESM(require("path"));
+var ANSI_RE = /\[[0-9;]*m/g;
+function endOfString(s, start) {
+  const q = s[start];
+  for (let i = start + 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === q) return i;
+  }
+  return s.length - 1;
+}
+function matchBrace(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}" && --depth === 0) return i;
+  }
+  return s.length - 1;
+}
+function parseOptions(src) {
+  const obj = {};
+  const re = /(\w+)\s*:\s*('(?:\\.|[^'])*'|"(?:\\.|[^"])*"|true|false|-?\d+)/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const key = m[1];
+    const raw = m[2];
+    if (raw === "true") obj[key] = true;
+    else if (raw === "false") obj[key] = false;
+    else if (/^-?\d+$/.test(raw)) obj[key] = Number(raw);
+    else obj[key] = raw.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  return obj;
+}
+function parseArgs(inner) {
+  const args = [];
+  let i = 0;
+  while (i < inner.length) {
+    const c = inner[i];
+    if (c === " " || c === ",") {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const end = endOfString(inner, i);
+      args.push(inner.slice(i + 1, end).replace(/\\(.)/g, "$1"));
+      i = end + 1;
+      continue;
+    }
+    if (c === "{") {
+      const end = matchBrace(inner, i);
+      args.push(parseOptions(inner.slice(i, end + 1)));
+      i = end + 1;
+      continue;
+    }
+    i++;
+  }
+  return args;
+}
+function leafExpression(expr) {
+  let depth = 0;
+  let leafStart = 0;
+  for (let i = 0; i < expr.length - 1; i++) {
+    const c = expr[i];
+    if (c === "'" || c === '"') {
+      i = endOfString(expr, i);
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0 && expr[i + 1] === ".") leafStart = i + 2;
+    }
+  }
+  return expr.slice(leafStart);
+}
+function parseLeafLocatorExpression(rawExpr) {
+  const expr = leafExpression(rawExpr.trim());
+  const m = /^([A-Za-z]+)\((.*)\)$/s.exec(expr);
+  if (!m) return null;
+  return { method: m[1], args: parseArgs(m[2].trim()) };
+}
+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_RE, "");
+    const line = /^\s*Locator:\s*(.+)$/m.exec(text);
+    if (!line) continue;
+    const parsed = parseLeafLocatorExpression(line[1].trim());
+    if (!parsed) continue;
+    const loc = err.location;
+    const location = loc ? `${path2.relative(process.cwd(), loc.file).split(path2.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    return { method: parsed.method, args: parsed.args, location };
+  }
+  return null;
+}
+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 } };
+  }
+  if (a.role && a.ariaLabel && a.labeledRoleCount === 1) {
     return {
-        networkRequests: [],
-        consoleEntries: [],
-        pendingHandlers: [],
-        capturedLocators: [],
-        capturePromises: [],
-        failedLocators: [],
-        lastActivePage: null,
-        testInfo: null,
-        stashedWebVitals: null,
-        stashedPageState: null,
-        stashedAria: null,
+      code: `getByRole('${escStr(a.role)}', { name: '${escStr(a.ariaLabel)}' })`,
+      kind: "labeledRole",
+      flatArgs: { anchorRole: a.role, anchorName: a.ariaLabel }
     };
+  }
+  if (a.role && a.roleCount === 1) {
+    return { code: `getByRole('${escStr(a.role)}')`, kind: "role", flatArgs: { anchorRole: a.role } };
+  }
+  return null;
 }
-/**
- * The capture sink for the test currently running in this worker. Playwright
- * runs a worker's tests sequentially, so a single "current" sink is unambiguous.
- * It is null between tests and during `beforeAll`/`afterAll` — activity outside a
- * test (auth setup, teardown) is intentionally not captured.
- */
-let currentSink = null;
-/**
- * Element probes whose protocol call is still in flight. Closing a page,
- * context, or browser while a probe is mid-flight makes Playwright's
- * connection dispatcher throw a global "Object with guid handle@… was not
- * bound in the connection" error, which fails whichever test happens to be
- * running. The close wrappers drain this set (bounded) before closing.
- */
-const PENDING_PROBES = new Set();
-async function drainPendingProbes(capMs) {
-    if (PENDING_PROBES.size === 0)
-        return;
-    let cap;
-    await Promise.race([
-        Promise.allSettled(PENDING_PROBES),
-        new Promise((resolve) => {
-            cap = setTimeout(resolve, capMs);
-        }),
-    ]);
-    clearTimeout(cap);
+function generateAnchoredAlternatives(leaf, anchors, chainLeafCount) {
+  if (!leaf.role || anchors.length === 0) return [];
+  const out = [];
+  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);
+    }
+  };
+  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.
+        args: { ...leafArgs, ...innermost.flatArgs, anchorChain: segments.map((s) => s.code) },
+        score
+      });
+    }
+  }
+  return out.sort((a, b) => b.score - a.score);
 }
-function isPageClosed(page) {
-    try {
-        return typeof page.isClosed === 'function' ? page.isClosed() : false;
+function mergeCandidates(base, extra) {
+  const seen = new Set(base.map((b) => b.locator));
+  const merged = [...base];
+  for (const e of extra) {
+    if (seen.has(e.locator)) continue;
+    seen.add(e.locator);
+    merged.push(e);
+  }
+  return merged.sort((a, b) => b.score - a.score);
+}
+function installPickerOverlay(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || !doc.body) {
+    g.__piwiPickState = "skipped";
+    return;
+  }
+  const Z = 2147483600;
+  const highlight = doc.createElement("div");
+  highlight.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};display:none;box-sizing:border-box;border:2px solid #7c3aed;background:rgba(124,58,237,.12);border-radius:3px;`;
+  const banner = doc.createElement("div");
+  banner.style.cssText = `position:fixed;top:12px;left:50%;transform:translateX(-50%);z-index:${Z + 2};background:#111827;color:#f9fafb;font:13px/1.5 system-ui,sans-serif;padding:10px 16px;border-radius:8px;box-shadow:0 4px 24px rgba(0,0,0,.4);max-width:80vw;`;
+  const hlLocator = (expr) => {
+    const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    let html = "";
+    let last = 0;
+    let m;
+    while ((m = re.exec(expr)) !== null) {
+      if (m.index > last) html += escHtml(expr.slice(last, m.index));
+      const color = m[1] ? "#4ade80" : m[2] ? "#c084fc" : m[3] ? "#93c5fd" : m[4] ? "#fbbf24" : "#9ca3af";
+      html += `<span style="color:${color}">${escHtml(m[0])}</span>`;
+      last = re.lastIndex;
+    }
+    if (last < expr.length) html += escHtml(expr.slice(last));
+    return `<code style="font-family:ui-monospace,SFMono-Regular,Menlo,monospace">${html}</code>`;
+  };
+  const head = doc.createElement("div");
+  head.innerHTML = arg.failing ? `Piwi locator picker \u2014 click the element that should replace ${hlLocator(arg.failing)}` : "Piwi inspector \u2014 click any element to generate locators for it";
+  const foot = doc.createElement("div");
+  foot.style.cssText = "color:#9ca3af;margin-top:3px;";
+  foot.textContent = "\u2191 parent \xB7 \u2193 child \xB7 Esc skip";
+  banner.appendChild(head);
+  banner.appendChild(foot);
+  doc.body.appendChild(highlight);
+  doc.body.appendChild(banner);
+  const escJs = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const describe = (el) => {
+    const tag = (el.tagName || "?").toLowerCase();
+    const testId = el.getAttribute && el.getAttribute("data-testid");
+    if (testId) return `getByTestId('${escJs(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)}')`;
+    }
+    const ariaLabel = el.getAttribute && el.getAttribute("aria-label");
+    if (ariaLabel) return `getByLabel('${escJs(ariaLabel)}')`;
+    const placeholder = el.getAttribute && el.getAttribute("placeholder");
+    if (placeholder) return `getByPlaceholder('${escJs(placeholder)}')`;
+    const alt = el.getAttribute && el.getAttribute("alt");
+    if (alt) return `getByAltText('${escJs(alt)}')`;
+    const titleAttr = el.getAttribute && el.getAttribute("title");
+    if (titleAttr) return `getByTitle('${escJs(titleAttr)}')`;
+    if (el.id) return `locator('#${escJs(el.id)}')`;
+    const cls = (el.getAttribute && el.getAttribute("class") || "").split(/\s+/).find((c) => c.length > 1);
+    return cls ? `locator('.${escJs(cls)}')` : tag;
+  };
+  const buildChain = (raw) => {
+    const chain2 = [];
+    let node = raw;
+    while (node && chain2.length < 15) {
+      const tag = (node.tagName || "").toLowerCase();
+      if (tag === "body" || tag === "html") break;
+      chain2.push(node);
+      node = node.parentElement;
     }
-    catch {
-        return false;
+    return chain2.length ? chain2 : [raw];
+  };
+  const ACTIONABLE_TAGS = ["button", "a", "input", "select", "textarea", "summary", "option"];
+  const snapIndex = (chain2) => {
+    for (let i = 0; i < Math.min(chain2.length, 4); i++) {
+      const el = chain2[i];
+      const tag = (el.tagName || "").toLowerCase();
+      if (ACTIONABLE_TAGS.includes(tag)) return i;
+      if (el.getAttribute && (el.getAttribute("role") || el.getAttribute("data-testid"))) return i;
     }
+    return 0;
+  };
+  let chain = [];
+  let idx = 0;
+  let lastRaw = null;
+  const current = () => chain[idx] ?? null;
+  const refresh = () => {
+    const el = current();
+    if (!el) {
+      highlight.style.display = "none";
+      return;
+    }
+    const r = el.getBoundingClientRect();
+    highlight.style.display = "block";
+    highlight.style.left = r.left + "px";
+    highlight.style.top = r.top + "px";
+    highlight.style.width = r.width + "px";
+    highlight.style.height = r.height + "px";
+    foot.textContent = `${describe(el)} \u2014 click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip`;
+  };
+  const stop = (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+  };
+  const isOwn = (el) => el === banner || el === highlight || banner.contains && banner.contains(el);
+  let bannerDocked = "top";
+  const dockBanner = (side) => {
+    if (bannerDocked === side) return;
+    bannerDocked = side;
+    if (side === "bottom") {
+      banner.style.top = "auto";
+      banner.style.bottom = "12px";
+    } else {
+      banner.style.top = "12px";
+      banner.style.bottom = "auto";
+    }
+  };
+  const onMove = (e) => {
+    const raw = e.target;
+    if (!raw || isOwn(raw)) {
+      highlight.style.display = "none";
+      return;
+    }
+    if (raw !== lastRaw) {
+      lastRaw = raw;
+      chain = buildChain(raw);
+      idx = snapIndex(chain);
+    }
+    refresh();
+    const el = current();
+    if (el) {
+      const r = el.getBoundingClientRect();
+      const br = banner.getBoundingClientRect();
+      const margin = 8;
+      if (r.left < br.right + margin && r.right > br.left - margin && r.top < br.bottom + margin && r.bottom > br.top - margin) {
+        dockBanner(bannerDocked === "top" ? "bottom" : "top");
+      }
+    }
+  };
+  const onClick = (e) => {
+    stop(e);
+    const el = current();
+    if (!el || isOwn(e.target)) return;
+    g.__piwiPickedElement = el;
+    g.__piwiPickState = "picked";
+    removeListeners();
+    highlight.style.display = "none";
+    foot.textContent = "Analyzing element\u2026";
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      stop(e);
+      g.__piwiPickState = "skipped";
+      cleanup();
+      return;
+    }
+    if (e.key === "ArrowUp" || e.key === "ArrowDown") {
+      stop(e);
+      if (e.key === "ArrowUp") idx = Math.min(idx + 1, chain.length - 1);
+      else idx = Math.max(idx - 1, 0);
+      refresh();
+    }
+  };
+  const suppressed = ["mousedown", "mouseup", "pointerdown", "pointerup", "auxclick", "dblclick"];
+  const removeListeners = () => {
+    doc.removeEventListener("mousemove", onMove, true);
+    doc.removeEventListener("click", onClick, true);
+    doc.removeEventListener("keydown", onKey, true);
+    for (const t of suppressed) doc.removeEventListener(t, stop, true);
+  };
+  const cleanup = () => {
+    removeListeners();
+    highlight.remove();
+    banner.remove();
+  };
+  g.__piwiPickCleanup = cleanup;
+  doc.addEventListener("mousemove", onMove, true);
+  doc.addEventListener("click", onClick, true);
+  doc.addEventListener("keydown", onKey, true);
+  for (const t of suppressed) doc.addEventListener(t, stop, true);
 }
-function pageContext(page) {
+function showAnchorPicker(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  const el = g.__piwiPickedElement;
+  if (!doc || !doc.body || !el) {
+    g.__piwiAnchorState = "skipped";
+    return;
+  }
+  const Z = 2147483600;
+  const { tagRoles, inputRoles, roleSources, leafRole, leafLevel, leafTestId } = arg;
+  const roleOf = (n) => {
+    const explicit = n.getAttribute && n.getAttribute("role");
+    if (explicit) return explicit;
+    const tag = (n.tagName || "").toLowerCase();
+    if (tag === "input") return inputRoles[(n.getAttribute("type") || "text").toLowerCase()] ?? "textbox";
+    if (tag === "select") return n.getAttribute("multiple") != null ? "listbox" : "combobox";
+    if (tag === "a") return n.getAttribute("href") != null ? "link" : null;
+    return tagRoles[tag] ?? null;
+  };
+  const levelOf = (n) => {
+    const m = /^h([1-6])$/.exec((n.tagName || "").toLowerCase());
+    if (m) return Number(m[1]);
+    const al = n.getAttribute && n.getAttribute("aria-level");
+    return al && /^\d+$/.test(al) ? Number(al) : null;
+  };
+  const leafMatches = (scope) => {
     try {
-        return typeof page.context === 'function' ? page.context() : null;
+      if (leafTestId) return scope.querySelectorAll(`[data-testid=${JSON.stringify(leafTestId)}]`).length;
+      const nodes = scope.querySelectorAll(roleSources);
+      if (nodes.length > 2e3) return -1;
+      let matched = 0;
+      for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        if (roleOf(n) !== leafRole) continue;
+        if (leafLevel != null && levelOf(n) !== leafLevel) continue;
+        matched++;
+      }
+      return matched;
+    } catch {
+      return -1;
     }
-    catch {
-        return null;
+  };
+  let roleNodes = [];
+  try {
+    const all = doc.querySelectorAll(roleSources);
+    if (all.length <= 4e3) roleNodes = Array.from(all);
+  } catch {
+    roleNodes = [];
+  }
+  const count = (sel) => {
+    try {
+      return doc.querySelectorAll(sel).length;
+    } catch {
+      return void 0;
     }
-}
-/** Read navigation/paint timings and core-vitals entries — null when unavailable or the page is gone. */
-async function readWebVitals(page) {
+  };
+  const rows = [];
+  let node = el.parentElement;
+  let depth = 0;
+  while (node && depth < 12) {
+    depth++;
+    const tag = (node.tagName || "").toLowerCase();
+    if (tag === "body" || tag === "html") break;
+    const testId = node.getAttribute("data-testid");
+    const id = node.getAttribute("id");
+    const ariaLabel = node.getAttribute("aria-label");
+    const role = roleOf(node);
+    const info = { tag, depth, testId: testId || null, id: id || null, ariaLabel: ariaLabel || null, role };
+    if (testId) info.testIdCount = count(`[data-testid=${JSON.stringify(testId)}]`);
+    if (id) {
+      try {
+        info.idCount = count(`#${doc.defaultView.CSS.escape(id)}`);
+      } catch {
+      }
+    }
+    if (role) {
+      let roleCount = 0;
+      let labeledCount = 0;
+      for (const n of roleNodes) {
+        if (roleOf(n) !== role) continue;
+        roleCount++;
+        if (ariaLabel && n.getAttribute && n.getAttribute("aria-label") === ariaLabel) labeledCount++;
+      }
+      info.roleCount = roleCount;
+      if (ariaLabel) info.labeledRoleCount = labeledCount;
+    }
+    info.scopedLeafCount = leafMatches(node);
+    const hookLabel = testId ? `data-testid="${testId}"` : id ? `#${id}` : ariaLabel && role ? `${role} "${ariaLabel}"` : role ? `role ${role}` : "no stable hook";
+    rows.push({
+      node,
+      info,
+      hookLabel,
+      selectable: !!(testId || id || role && (ariaLabel || info.roleCount === 1))
+    });
+    node = node.parentElement;
+  }
+  if (rows.length === 0) {
+    g.__piwiAnchorState = "skipped";
+    return;
+  }
+  const outline = doc.createElement("div");
+  outline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #22c55e;border-radius:3px;display:none;`;
+  const pickedOutline = doc.createElement("div");
+  const pr = el.getBoundingClientRect();
+  pickedOutline.style.cssText = `position:fixed;pointer-events:none;z-index:${Z};box-sizing:border-box;border:2px solid #7c3aed;background:rgba(124,58,237,.10);border-radius:3px;left:${pr.left}px;top:${pr.top}px;width:${pr.width}px;height:${pr.height}px;`;
+  const panel = doc.createElement("div");
+  panel.style.cssText = `position:fixed;top:12px;right:12px;z-index:${Z + 3};width:340px;max-height:82vh;overflow:auto;background:#111827;color:#f9fafb;border-radius:10px;padding:16px;font:12px/1.5 system-ui,sans-serif;box-shadow:0 8px 40px rgba(0,0,0,.5);`;
+  const title = doc.createElement("div");
+  title.style.cssText = "font-weight:600;font-size:13px;margin-bottom:2px;";
+  title.textContent = "Scope to stable parents (optional)";
+  const sub = doc.createElement("div");
+  sub.style.cssText = "color:#9ca3af;margin-bottom:10px;";
+  sub.textContent = "Pick one or more parents to anchor the locator to. Hover a row to see the parent.";
+  panel.appendChild(title);
+  panel.appendChild(sub);
+  const selected = /* @__PURE__ */ new Set();
+  const footer = doc.createElement("div");
+  footer.style.cssText = "margin:10px 0;font-weight:600;";
+  const segMatches = (scope, info) => {
     try {
-        // Runs in the browser, so the perf-entry reads stay `any` (no DOM lib);
-        // the callback return type pins the result. Aggregation happens Node-side
-        // in computeCoreVitals so the in-page code stays a thin projection.
-        const probe = await page.evaluate(async () => {
-            const navEntries = performance.getEntriesByType('navigation');
-            const paintEntries = performance.getEntriesByType('paint');
-            const nav = navEntries[0];
-            const navigation = nav
-                ? {
-                    url: nav.name,
-                    ttfb: Math.round(nav.responseStart - nav.fetchStart),
-                    domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
-                    domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
-                    loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
-                    transferSize: nav.transferSize || 0,
-                    encodedBodySize: nav.encodedBodySize || 0,
-                    decodedBodySize: nav.decodedBodySize || 0,
-                }
-                : null;
-            const paint = {};
-            for (const entry of paintEntries) {
-                const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
-                paint[key] = Math.round(entry.startTime);
-            }
-            // Buffered-observer read of an entry type. Returns null when the type is
-            // unsupported (non-Chromium); [] when supported but nothing recorded.
-            // Buffered entries are dispatched in a queued task, so wait one macrotask
-            // before draining with takeRecords().
-            const readBuffered = (type, extra) => new Promise((resolve) => {
-                try {
-                    const PO = globalThis.PerformanceObserver;
-                    if (!PO || !(PO.supportedEntryTypes || []).includes(type))
-                        return resolve(null);
-                    const out = [];
-                    const po = new PO((list) => out.push(...list.getEntries()));
-                    po.observe({ type, buffered: true, ...extra });
-                    setTimeout(() => {
-                        try {
-                            out.push(...po.takeRecords());
-                            po.disconnect();
-                        }
-                        catch {
-                            // Entries gathered so far still count.
-                        }
-                        resolve(out);
-                    }, 0);
-                }
-                catch {
-                    resolve(null);
-                }
-            });
-            const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
-                readBuffered('largest-contentful-paint'),
-                readBuffered('layout-shift'),
-                // durationThreshold 40 mirrors the web-vitals library — captures every
-                // interaction slow enough to matter without flooding the buffer.
-                readBuffered('event', { durationThreshold: 40 }),
-                readBuffered('first-input'),
-            ]);
-            const project = (entries) => entries === null
-                ? null
-                : entries.map((e) => ({
-                    startTime: e.startTime,
-                    value: e.value,
-                    hadRecentInput: e.hadRecentInput,
-                    interactionId: e.interactionId,
-                    duration: e.duration,
-                }));
-            const interactionEntries = eventRaw === null && firstInputRaw === null ? null : [...(eventRaw ?? []), ...(firstInputRaw ?? [])];
-            return {
-                navigation,
-                paint,
-                lcpEntries: project(lcpRaw),
-                shiftEntries: project(shiftRaw),
-                eventEntries: project(interactionEntries),
-            };
-        });
-        if (!probe)
-            return null;
-        const vitals = computeCoreVitals(probe.lcpEntries, probe.shiftEntries, probe.eventEntries);
-        if (!probe.navigation && Object.keys(probe.paint).length === 0 && !vitals)
-            return null;
-        return { navigation: probe.navigation, paint: probe.paint, vitals };
+      if (info.testId) return Array.from(scope.querySelectorAll(`[data-testid=${JSON.stringify(info.testId)}]`));
+      if (info.id) return Array.from(scope.querySelectorAll(`#${doc.defaultView.CSS.escape(info.id)}`));
+      const nodes = Array.from(scope.querySelectorAll(roleSources));
+      if (nodes.length > 2e3) return [];
+      return nodes.filter(
+        (n) => roleOf(n) === info.role && (!info.ariaLabel || n.getAttribute && n.getAttribute("aria-label") === info.ariaLabel)
+      );
+    } catch {
+      return [];
+    }
+  };
+  const chainCount = () => {
+    const chosen = rows.filter((_, i) => selected.has(i)).sort((a, b) => b.info.depth - a.info.depth);
+    if (chosen.length === 0) return -1;
+    let scopes = [doc];
+    for (const row of chosen) {
+      const next = [];
+      for (const s of scopes) next.push(...segMatches(s, row.info));
+      scopes = next.slice(0, 200);
+      if (scopes.length === 0) return 0;
+    }
+    let total = 0;
+    for (const s of scopes) {
+      const c = leafMatches(s);
+      if (c > 0) total += c;
+      if (total > 50) return total;
+    }
+    return total;
+  };
+  const refreshFooter = () => {
+    if (selected.size === 0) {
+      footer.textContent = "No parents selected \u2014 standard alternatives only.";
+      footer.style.color = "#9ca3af";
+      g.__piwiPickChainCount = void 0;
+      return;
     }
-    catch {
-        return null;
+    const c = chainCount();
+    g.__piwiPickChainCount = c;
+    if (c === 1) {
+      footer.textContent = "\u2713 Selection matches exactly 1 element";
+      footer.style.color = "#4ade80";
+    } else {
+      footer.textContent = c < 0 ? "Match count unavailable" : `\u2717 Selection matches ${c} elements`;
+      footer.style.color = "#fbbf24";
     }
+  };
+  rows.forEach((row, i) => {
+    const line = doc.createElement("label");
+    line.style.cssText = `display:flex;align-items:center;gap:8px;padding:6px 8px;border:1px solid #374151;border-radius:6px;margin-bottom:6px;cursor:${row.selectable ? "pointer" : "default"};opacity:${row.selectable ? "1" : ".45"};`;
+    const box = doc.createElement("input");
+    box.type = "checkbox";
+    box.disabled = !row.selectable;
+    const text = doc.createElement("span");
+    text.style.cssText = "flex:1;min-width:0;";
+    const code = doc.createElement("code");
+    code.style.cssText = "display:block;font:11px ui-monospace,monospace;color:#e5e7eb;word-break:break-all;";
+    code.textContent = `<${row.info.tag}> ${row.hookLabel}`;
+    const hint = doc.createElement("span");
+    hint.style.cssText = "color:#9ca3af;";
+    hint.textContent = row.selectable ? row.info.scopedLeafCount === 1 ? "contains exactly 1 matching element" : `contains ${row.info.scopedLeafCount ?? "?"} matching elements` : "add a data-testid to make this usable";
+    text.appendChild(code);
+    text.appendChild(hint);
+    line.appendChild(box);
+    line.appendChild(text);
+    line.addEventListener("mouseenter", () => {
+      const r = row.node.getBoundingClientRect();
+      outline.style.display = "block";
+      outline.style.left = r.left + "px";
+      outline.style.top = r.top + "px";
+      outline.style.width = r.width + "px";
+      outline.style.height = r.height + "px";
+    });
+    line.addEventListener("mouseleave", () => {
+      outline.style.display = "none";
+    });
+    box.addEventListener("change", () => {
+      if (box.checked) selected.add(i);
+      else selected.delete(i);
+      refreshFooter();
+    });
+    panel.appendChild(line);
+  });
+  panel.appendChild(footer);
+  const cleanup = () => {
+    doc.removeEventListener("keydown", onKey, true);
+    panel.remove();
+    outline.remove();
+    pickedOutline.remove();
+  };
+  const done = (state) => {
+    g.__piwiPickAnchors = state === "done" ? rows.filter((_, i) => selected.has(i)).map((r) => r.info) : [];
+    g.__piwiAnchorState = state;
+    cleanup();
+  };
+  const onKey = (e) => {
+    if (e.key !== "Escape") return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done("skipped");
+  };
+  const buttonRow = doc.createElement("div");
+  buttonRow.style.cssText = "display:flex;gap:8px;margin-top:4px;";
+  const useBtn = doc.createElement("button");
+  useBtn.style.cssText = "flex:1;background:#7c3aed;color:#fff;border:none;border-radius:6px;padding:8px;cursor:pointer;font:600 12px system-ui;";
+  useBtn.textContent = "Use selected parents";
+  useBtn.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(selected.size > 0 ? "done" : "skipped");
+  });
+  const skipBtn = doc.createElement("button");
+  skipBtn.style.cssText = "background:none;border:1px solid #374151;color:#9ca3af;border-radius:6px;padding:8px 10px;cursor:pointer;font:12px system-ui;";
+  skipBtn.textContent = "Skip (Esc)";
+  skipBtn.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done("skipped");
+  });
+  buttonRow.appendChild(useBtn);
+  buttonRow.appendChild(skipBtn);
+  panel.appendChild(buttonRow);
+  refreshFooter();
+  g.__piwiAnchorCleanup = cleanup;
+  doc.addEventListener("keydown", onKey, true);
+  doc.body.appendChild(pickedOutline);
+  doc.body.appendChild(outline);
+  doc.body.appendChild(panel);
 }
-const PAGE_STATE_MAX_STORAGE_KEYS = 50;
-const PAGE_STATE_MAX_COOKIES = 30;
-const PAGE_STATE_HISTORY_CAP = 2048;
-const TOKEN_MASK_RES = [/\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g, /\b[0-9a-f]{32,}\b/gi];
-/**
- * Assemble the wire page-state from the in-page reads and the context cookies.
- * Pure and Node-side so the sanitization (token masking, caps, value-free
- * cookies) is unit-testable.
- */
-function buildPageState(raw, cookies) {
-    let historyState = raw.historyState;
-    if (historyState) {
-        for (const re of TOKEN_MASK_RES)
-            historyState = historyState.replace(re, '[masked]');
-        if (historyState.length > PAGE_STATE_HISTORY_CAP) {
-            historyState = historyState.slice(0, PAGE_STATE_HISTORY_CAP) + '…';
-        }
+function showPickerChoices(arg) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || !doc.body) {
+    g.__piwiPickChoice = -1;
+    return;
+  }
+  const Z = 2147483600;
+  const wrap = doc.createElement("div");
+  wrap.style.cssText = `position:fixed;inset:0;z-index:${Z + 3};background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;font:13px/1.5 system-ui,sans-serif;`;
+  const panel = doc.createElement("div");
+  panel.style.cssText = "background:#111827;color:#f9fafb;border-radius:10px;padding:20px;max-width:640px;width:90vw;max-height:70vh;overflow:auto;box-shadow:0 8px 40px rgba(0,0,0,.5);";
+  const hlLocator = (expr) => {
+    const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    let html = "";
+    let last = 0;
+    let m;
+    while ((m = re.exec(expr)) !== null) {
+      if (m.index > last) html += escHtml(expr.slice(last, m.index));
+      const color = m[1] ? "#4ade80" : m[2] ? "#c084fc" : m[3] ? "#93c5fd" : m[4] ? "#fbbf24" : "#9ca3af";
+      html += `<span style="color:${color}">${escHtml(m[0])}</span>`;
+      last = re.lastIndex;
     }
-    const capStorage = (entries) => (Array.isArray(entries) ? entries : []).slice(0, PAGE_STATE_MAX_STORAGE_KEYS).map((e) => ({
-        key: String(e.key).slice(0, 200),
-        length: typeof e.length === 'number' ? e.length : 0,
-    }));
+    if (last < expr.length) html += escHtml(expr.slice(last));
+    return html;
+  };
+  const title = doc.createElement("div");
+  title.style.cssText = "font-weight:600;margin-bottom:4px;";
+  title.textContent = arg.failing ? "Pick a replacement locator" : "Pick a locator";
+  const sub = doc.createElement("div");
+  sub.style.cssText = "color:#9ca3af;margin-bottom:12px;";
+  if (arg.failing) {
+    sub.innerHTML = `Replaces <code style="font-family:ui-monospace,Menlo,monospace">${hlLocator(arg.failing)}</code> \u2014 ranked by stability score.`;
+  } else {
+    sub.textContent = "For the element you picked \u2014 ranked by stability score.";
+  }
+  panel.appendChild(title);
+  panel.appendChild(sub);
+  const done = (choice) => {
+    g.__piwiPickChoice = choice;
+    doc.removeEventListener("keydown", onKey, true);
+    wrap.remove();
+  };
+  const onKey = (e) => {
+    if (e.key !== "Escape") return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(-1);
+  };
+  arg.choices.forEach((c, i) => {
+    const btn = doc.createElement("button");
+    btn.style.cssText = "display:flex;justify-content:space-between;align-items:center;gap:12px;width:100%;text-align:left;background:#1f2937;color:#e5e7eb;border:1px solid #374151;border-radius:6px;padding:8px 12px;margin:0 0 8px;cursor:pointer;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;";
+    const code = doc.createElement("span");
+    code.innerHTML = hlLocator(c.locator);
+    code.style.cssText = "word-break:break-all;";
+    const score = doc.createElement("span");
+    score.textContent = String(c.score);
+    score.style.cssText = "color:#a78bfa;flex-shrink:0;";
+    btn.appendChild(code);
+    btn.appendChild(score);
+    btn.addEventListener("click", (e) => {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      done(i);
+    });
+    panel.appendChild(btn);
+  });
+  const skip = doc.createElement("button");
+  skip.style.cssText = "background:none;border:none;color:#9ca3af;cursor:pointer;padding:6px 0 0;font:12px system-ui,sans-serif;";
+  skip.textContent = "Skip \u2014 keep the failure as-is (Esc)";
+  skip.addEventListener("click", (e) => {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    done(-1);
+  });
+  panel.appendChild(skip);
+  doc.addEventListener("keydown", onKey, true);
+  wrap.appendChild(panel);
+  doc.body.appendChild(wrap);
+}
+async function cleanupPicker(page) {
+  try {
+    await page.evaluate(() => {
+      const g = globalThis;
+      if (typeof g.__piwiPickCleanup === "function") g.__piwiPickCleanup();
+      if (typeof g.__piwiAnchorCleanup === "function") g.__piwiAnchorCleanup();
+      delete g.__piwiPickCleanup;
+      delete g.__piwiAnchorCleanup;
+      delete g.__piwiPickState;
+      delete g.__piwiPickChoice;
+      delete g.__piwiPickedElement;
+      delete g.__piwiAnchorState;
+      delete g.__piwiPickAnchors;
+      delete g.__piwiPickChainCount;
+    });
+  } catch {
+  }
+}
+async function runLocatorPicker(page, testInfo, failed, probe) {
+  try {
+    testInfo.setTimeout(0);
+    const rendered = failed ? renderFailing(failed) : null;
+    console.log(
+      `
+[piwi] "${testInfo.title}" ${testInfo.status} \u2014 ${rendered ? "locator picker" : "inspector"} open in the browser: ${rendered ? `click the element that should replace ${rendered}` : "click any element to generate locators for it"} (\u2191/\u2193 to select a parent/child, Esc to skip).`
+    );
+    await page.evaluate(installPickerOverlay, { failing: rendered });
+    await page.waitForFunction(() => globalThis.__piwiPickState !== void 0, void 0, {
+      timeout: 0,
+      polling: 250
+    });
+    const state = await page.evaluate(() => globalThis.__piwiPickState);
+    if (state !== "picked") {
+      await cleanupPicker(page);
+      return null;
+    }
+    const handle = await page.evaluateHandle(() => globalThis.__piwiPickedElement);
+    const attrs = await handle.evaluate(probe.fn, probe.arg);
+    await handle.dispose();
+    const accessibleName = approximateAccessibleName({ ...attrs, accessibleName: null });
+    const role = resolveAriaRole({ ...attrs, accessibleName });
+    const level = headingLevel({ ...attrs, accessibleName }, role);
+    let anchors = [];
+    let chainLeafCount;
+    if (role) {
+      const probeArg = probe.arg;
+      await page.evaluate(showAnchorPicker, {
+        tagRoles: probeArg.tagRoles,
+        inputRoles: probeArg.inputRoles,
+        roleSources: probeArg.roleSources,
+        leafRole: role,
+        leafLevel: level,
+        leafTestId: attrs.attributes["data-testid"] ?? null
+      });
+      await page.waitForFunction(() => globalThis.__piwiAnchorState !== void 0, void 0, {
+        timeout: 0,
+        polling: 250
+      });
+      const anchorResult = await page.evaluate(() => {
+        const g = globalThis;
+        return { state: g.__piwiAnchorState, anchors: g.__piwiPickAnchors ?? [], chainCount: g.__piwiPickChainCount };
+      });
+      if (anchorResult.state === "done" && anchorResult.anchors.length > 0) {
+        anchors = anchorResult.anchors;
+        chainLeafCount = anchorResult.chainCount;
+      }
+    }
+    const ranked = mergeCandidates(
+      generateAlternatives({ ...attrs, accessibleName }),
+      generateAnchoredAlternatives({ role, level }, anchors, chainLeafCount)
+    );
+    if (ranked.length === 0) {
+      console.log("[piwi] No stable locator could be generated for the picked element \u2014 nothing recorded.");
+      await cleanupPicker(page);
+      return null;
+    }
+    await page.evaluate(showPickerChoices, {
+      failing: rendered,
+      choices: ranked.map((r) => ({ locator: r.locator, score: r.score }))
+    });
+    await page.waitForFunction(() => globalThis.__piwiPickChoice !== void 0, void 0, {
+      timeout: 0,
+      polling: 250
+    });
+    const choice = await page.evaluate(() => globalThis.__piwiPickChoice);
+    await cleanupPicker(page);
+    if (typeof choice !== "number" || choice < 0 || choice >= ranked.length) return null;
+    const picked = { ...ranked[choice], pickedByUser: true };
+    const alternatives = [picked, ...ranked.filter((_, i) => i !== choice)];
+    const element = {
+      tagName: attrs.tagName,
+      attributes: attrs.attributes,
+      textContent: attrs.textContent,
+      accessibleName,
+      center: attrs.center,
+      ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
+      ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
+    };
+    const location = failed?.location ?? null;
+    console.log(
+      failed ? `[piwi] Replacement picked for ${rendered}${location ? ` at ${location}` : ""}:
+[piwi]   ${picked.locator}` : `[piwi] Locator picked while inspecting:
+[piwi]   ${picked.locator}`
+    );
     return {
-        url: raw.url,
-        hash: raw.hash || null,
-        historyState: historyState || null,
-        localStorage: capStorage(raw.localStorage),
-        sessionStorage: capStorage(raw.sessionStorage),
-        cookies: (cookies ?? []).slice(0, PAGE_STATE_MAX_COOKIES).map((c) => ({
-            name: String(c.name ?? ''),
-            domain: String(c.domain ?? ''),
-            path: String(c.path ?? ''),
-            httpOnly: Boolean(c.httpOnly),
-            secure: Boolean(c.secure),
-            ...(c.sameSite !== undefined ? { sameSite: String(c.sameSite) } : {}),
-            ...(typeof c.expires === 'number' ? { expires: c.expires } : {}),
-        })),
+      failing: failed ? { method: failed.method, args: failed.args, rendered, location } : null,
+      picked,
+      alternatives,
+      element,
+      ...anchors.length > 0 ? { anchors } : {}
     };
+  } catch {
+    return null;
+  }
 }
-/** Read the page's state — null when unavailable or the page is gone. */
-async function readPageState(page) {
-    try {
-        const raw = await page.evaluate(() => {
-            // Key names + value lengths only — values never leave the page.
-            const listStorage = (s) => {
-                const out = [];
-                try {
-                    for (let i = 0; i < s.length; i++) {
-                        const key = s.key(i);
-                        if (key != null)
-                            out.push({ key, length: (s.getItem(key) ?? '').length });
-                    }
-                }
-                catch {
-                    // Storage access can throw in sandboxed/opaque-origin pages.
-                }
-                return out;
-            };
-            const g = globalThis;
-            let historyState = null;
+function applyPickToSnapshots(snapshots, pick) {
+  if (!pick.failing?.location) return false;
+  const failing = pick.failing;
+  for (let i = snapshots.length - 1; i >= 0; i--) {
+    const snap = snapshots[i];
+    if (snap.location !== failing.location || snap.element) continue;
+    snapshots[i] = {
+      location: snap.location,
+      used: snap.used,
+      element: pick.element,
+      alternatives: pick.alternatives.slice(0, 10)
+    };
+    return true;
+  }
+  snapshots.push({
+    location: failing.location,
+    used: {
+      method: failing.method,
+      args: failing.args,
+      raw: `${failing.method}(${JSON.stringify(failing.args)})`
+    },
+    element: pick.element,
+    alternatives: pick.alternatives.slice(0, 10)
+  });
+  return true;
+}
+
+// src/internal/capture/capture-fixtures.ts
+function computeCoreVitals(lcpEntries, shiftEntries, eventEntries) {
+  const lastLcp = lcpEntries && lcpEntries.length > 0 ? lcpEntries[lcpEntries.length - 1] : null;
+  const lcp = lastLcp && typeof lastLcp.startTime === "number" ? Math.round(lastLcp.startTime) : null;
+  let cls = null;
+  if (shiftEntries) {
+    const sum = shiftEntries.reduce(
+      (acc, e) => acc + (e.hadRecentInput ? 0 : typeof e.value === "number" ? e.value : 0),
+      0
+    );
+    cls = Math.round(sum * 1e4) / 1e4;
+  }
+  let inp = null;
+  if (eventEntries && eventEntries.length > 0) {
+    const byInteraction = /* @__PURE__ */ new Map();
+    for (const e of eventEntries) {
+      if (typeof e.interactionId !== "number" || e.interactionId <= 0) continue;
+      const duration = typeof e.duration === "number" ? e.duration : 0;
+      const prev = byInteraction.get(e.interactionId) ?? 0;
+      if (duration > prev) byInteraction.set(e.interactionId, duration);
+    }
+    const durations = [...byInteraction.values()].sort((a, b) => a - b);
+    if (durations.length > 0) {
+      const index = durations.length > 50 ? Math.floor(durations.length * 0.98) : durations.length - 1;
+      inp = Math.round(durations[Math.min(index, durations.length - 1)]);
+    }
+  }
+  if (lcp === null && cls === null && inp === null) return null;
+  return { lcp, cls, inp };
+}
+function createSink() {
+  return {
+    networkRequests: [],
+    consoleEntries: [],
+    pendingHandlers: [],
+    capturedLocators: [],
+    capturePromises: [],
+    failedLocators: [],
+    lastActivePage: null,
+    testInfo: null,
+    stashedWebVitals: null,
+    stashedPageState: null,
+    stashedAria: null,
+    pickOffered: false,
+    userPick: null
+  };
+}
+var currentSink = null;
+var PENDING_PROBES = /* @__PURE__ */ new Set();
+async function drainPendingProbes(capMs) {
+  if (PENDING_PROBES.size === 0) return;
+  let cap;
+  await Promise.race([
+    Promise.allSettled(PENDING_PROBES),
+    new Promise((resolve) => {
+      cap = setTimeout(resolve, capMs);
+    })
+  ]);
+  clearTimeout(cap);
+}
+function isPageClosed(page) {
+  try {
+    return typeof page.isClosed === "function" ? page.isClosed() : false;
+  } catch {
+    return false;
+  }
+}
+function pageContext(page) {
+  try {
+    return typeof page.context === "function" ? page.context() : null;
+  } catch {
+    return null;
+  }
+}
+async function readWebVitals(page) {
+  try {
+    const probe = await page.evaluate(async () => {
+      const navEntries = performance.getEntriesByType("navigation");
+      const paintEntries = performance.getEntriesByType("paint");
+      const nav = navEntries[0];
+      const navigation = nav ? {
+        url: nav.name,
+        ttfb: Math.round(nav.responseStart - nav.fetchStart),
+        domInteractive: Math.round(nav.domInteractive - nav.fetchStart),
+        domContentLoaded: Math.round(nav.domContentLoadedEventEnd - nav.fetchStart),
+        loadComplete: Math.round(nav.loadEventEnd - nav.fetchStart),
+        transferSize: nav.transferSize || 0,
+        encodedBodySize: nav.encodedBodySize || 0,
+        decodedBodySize: nav.decodedBodySize || 0
+      } : null;
+      const paint = {};
+      for (const entry of paintEntries) {
+        const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+        paint[key] = Math.round(entry.startTime);
+      }
+      const readBuffered = (type, extra) => new Promise((resolve) => {
+        try {
+          const PO = globalThis.PerformanceObserver;
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve(null);
+          const out = [];
+          const po = new PO((list) => out.push(...list.getEntries()));
+          po.observe({ type, buffered: true, ...extra });
+          setTimeout(() => {
             try {
-                historyState = g.history?.state == null ? null : JSON.stringify(g.history.state);
+              out.push(...po.takeRecords());
+              po.disconnect();
+            } catch {
             }
-            catch {
-                // Unserializable history state.
-            }
-            return {
-                url: g.location.href,
-                hash: g.location.hash || null,
-                historyState,
-                localStorage: listStorage(globalThis.localStorage),
-                sessionStorage: listStorage(globalThis.sessionStorage),
-            };
-        });
-        if (!raw)
-            return null;
-        // Cookie flags are only reachable from the context API, never document.cookie.
-        let cookies = null;
-        try {
-            cookies = (await pageContext(page)?.cookies()) ?? null;
+            resolve(out);
+          }, 0);
+        } catch {
+          resolve(null);
         }
-        catch {
-            cookies = null;
-        }
-        return buildPageState(raw, cookies);
+      });
+      const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
+        readBuffered("largest-contentful-paint"),
+        readBuffered("layout-shift"),
+        // durationThreshold 40 mirrors the web-vitals library — captures every
+        // interaction slow enough to matter without flooding the buffer.
+        readBuffered("event", { durationThreshold: 40 }),
+        readBuffered("first-input")
+      ]);
+      const project = (entries) => entries === null ? null : entries.map((e) => ({
+        startTime: e.startTime,
+        value: e.value,
+        hadRecentInput: e.hadRecentInput,
+        interactionId: e.interactionId,
+        duration: e.duration
+      }));
+      const interactionEntries = eventRaw === null && firstInputRaw === null ? null : [...eventRaw ?? [], ...firstInputRaw ?? []];
+      return {
+        navigation,
+        paint,
+        lcpEntries: project(lcpRaw),
+        shiftEntries: project(shiftRaw),
+        eventEntries: project(interactionEntries)
+      };
+    });
+    if (!probe) return null;
+    const vitals = computeCoreVitals(probe.lcpEntries, probe.shiftEntries, probe.eventEntries);
+    if (!probe.navigation && Object.keys(probe.paint).length === 0 && !vitals) return null;
+    return { navigation: probe.navigation, paint: probe.paint, vitals };
+  } catch {
+    return null;
+  }
+}
+var PAGE_STATE_MAX_STORAGE_KEYS = 50;
+var PAGE_STATE_MAX_COOKIES = 30;
+var PAGE_STATE_HISTORY_CAP = 2048;
+var TOKEN_MASK_RES = [/\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g, /\b[0-9a-f]{32,}\b/gi];
+function buildPageState(raw, cookies) {
+  let historyState = raw.historyState;
+  if (historyState) {
+    for (const re of TOKEN_MASK_RES) historyState = historyState.replace(re, "[masked]");
+    if (historyState.length > PAGE_STATE_HISTORY_CAP) {
+      historyState = historyState.slice(0, PAGE_STATE_HISTORY_CAP) + "\u2026";
     }
-    catch {
-        return null;
+  }
+  const capStorage = (entries) => (Array.isArray(entries) ? entries : []).slice(0, PAGE_STATE_MAX_STORAGE_KEYS).map((e) => ({
+    key: String(e.key).slice(0, 200),
+    length: typeof e.length === "number" ? e.length : 0
+  }));
+  return {
+    url: raw.url,
+    hash: raw.hash || null,
+    historyState: historyState || null,
+    localStorage: capStorage(raw.localStorage),
+    sessionStorage: capStorage(raw.sessionStorage),
+    cookies: (cookies ?? []).slice(0, PAGE_STATE_MAX_COOKIES).map((c) => ({
+      name: String(c.name ?? ""),
+      domain: String(c.domain ?? ""),
+      path: String(c.path ?? ""),
+      httpOnly: Boolean(c.httpOnly),
+      secure: Boolean(c.secure),
+      ...c.sameSite !== void 0 ? { sameSite: String(c.sameSite) } : {},
+      ...typeof c.expires === "number" ? { expires: c.expires } : {}
+    }))
+  };
+}
+async function readPageState(page) {
+  try {
+    const raw = await page.evaluate(() => {
+      const listStorage = (s) => {
+        const out = [];
+        try {
+          for (let i = 0; i < s.length; i++) {
+            const key = s.key(i);
+            if (key != null) out.push({ key, length: (s.getItem(key) ?? "").length });
+          }
+        } catch {
+        }
+        return out;
+      };
+      const g = globalThis;
+      let historyState = null;
+      try {
+        historyState = g.history?.state == null ? null : JSON.stringify(g.history.state);
+      } catch {
+      }
+      return {
+        url: g.location.href,
+        hash: g.location.hash || null,
+        historyState,
+        localStorage: listStorage(globalThis.localStorage),
+        sessionStorage: listStorage(globalThis.sessionStorage)
+      };
+    });
+    if (!raw) return null;
+    let cookies = null;
+    try {
+      cookies = await pageContext(page)?.cookies() ?? null;
+    } catch {
+      cookies = null;
     }
+    return buildPageState(raw, cookies);
+  } catch {
+    return null;
+  }
 }
-/**
- * Take the page-dependent teardown reads (web vitals; page state; ARIA
- * snapshot when the test failed) while the last active page is still open.
- * Called by the close wrappers just before a close that would take that page
- * with it — flushSink runs too late for a live read on the standard test page.
- */
 async function stashPageState(sink, closing) {
-    const page = sink.lastActivePage;
-    if (!page || isPageClosed(page))
-        return;
-    const belongsToClosing = closing.page === page || (closing.context !== undefined && pageContext(page) === closing.context);
-    if (!belongsToClosing)
-        return;
-    const vitals = await readWebVitals(page);
-    if (vitals)
-        sink.stashedWebVitals = vitals;
-    if (process.env.PIWI_CAPTURE_PAGE_STATE !== 'false') {
-        const pageState = await readPageState(page);
-        if (pageState)
-            sink.stashedPageState = pageState;
-    }
-    const status = sink.testInfo?.status;
-    if (status === 'failed' || status === 'timedOut' || status === 'interrupted') {
-        const aria = await ariaSnapshotBestEffort(page.locator(':root'), 1000);
-        if (aria)
-            sink.stashedAria = aria;
-    }
+  const page = sink.lastActivePage;
+  if (!page || isPageClosed(page)) return;
+  const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
+  if (!belongsToClosing) return;
+  const vitals = await readWebVitals(page);
+  if (vitals) sink.stashedWebVitals = vitals;
+  if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
+    const pageState = await readPageState(page);
+    if (pageState) sink.stashedPageState = pageState;
+  }
+  const status = sink.testInfo?.status;
+  if (status === "failed" || status === "timedOut" || status === "interrupted") {
+    const aria = await ariaSnapshotBestEffort(page.locator(":root"), 1e3);
+    if (aria) sink.stashedAria = aria;
+  }
+}
+async function maybeOpenPicker(sink, closing) {
+  if (sink.pickOffered) return;
+  const page = sink.lastActivePage;
+  const testInfo = sink.testInfo;
+  if (!page || !testInfo || isPageClosed(page)) return;
+  if (closing) {
+    const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
+    if (!belongsToClosing) return;
+  }
+  const pickGate = shouldInspectOnFailure(inspectionGateFromTestInfo(testInfo, process.env.PIWI_PICK_LOCATOR_ON_FAIL));
+  const inspectGate = shouldInspectOnFailure(inspectionGateFromTestInfo(testInfo, process.env.PIWI_INSPECT_ON_FAIL));
+  if (!pickGate && !inspectGate) return;
+  sink.pickOffered = true;
+  const failed = sink.failedLocators[sink.failedLocators.length - 1] ?? deriveFailedLocator(testInfo);
+  if (!failed && !inspectGate) {
+    console.log("[piwi] locator picker: no failing locator could be identified in this failure \u2014 nothing to replace.");
+    return;
+  }
+  const pick = await runLocatorPicker(page, testInfo, failed, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG });
+  if (!pick) return;
+  sink.userPick = pick;
+  applyPickToSnapshots(sink.capturedLocators, pick);
 }
-// Idempotency guards: a page/context/browser can be reached through several
-// paths (browser patch, context patch, the `page` fixture, popup events), and
-// must be wrapped exactly once.
-const INSTRUMENTED_PAGES = new WeakSet();
-const INSTRUMENTED_CONTEXTS = new WeakSet();
-const PATCHED_BROWSERS = new WeakSet();
-// O(1) membership for the proxy `get` trap below, which runs on every property
-// access of every wrapped locator. The source arrays from locator-healing are
-// turned into Sets once here.
-const CHAIN_METHOD_SET = new Set(locator_healing_js_1.CHAIN_METHODS);
-const ACTION_METHOD_SET = new Set(locator_healing_js_1.ACTION_METHODS);
-const FORM_FIELD_TAGS = new Set(['input', 'select', 'textarea']);
-/** Built once — passed verbatim into evaluate() on every action. */
-exports.CAPTURED_ATTRS_ARG = {
-    keep: [...locator_healing_js_1.CAPTURED_ATTRIBUTES],
-    tagRoles: locator_healing_js_1.TAG_TO_ROLE,
-    inputRoles: locator_healing_js_1.INPUT_TYPE_TO_ROLE,
-    // '[role]' plus every tag the maps can resolve (input/select are handled by
-    // special-cased logic in the probe, so add them explicitly).
-    roleSources: [...new Set(['[role]', 'input', 'select', ...Object.keys(locator_healing_js_1.TAG_TO_ROLE)])].join(','),
+var INSTRUMENTED_PAGES = /* @__PURE__ */ new WeakSet();
+var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
+var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
+var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
+var ACTION_METHOD_SET = new Set(ACTION_METHODS);
+var FORM_FIELD_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea"]);
+var CAPTURED_ATTRS_ARG = {
+  keep: [...CAPTURED_ATTRIBUTES],
+  tagRoles: TAG_TO_ROLE,
+  inputRoles: INPUT_TYPE_TO_ROLE,
+  // '[role]' plus every tag the maps can resolve (input/select are handled by
+  // special-cased logic in the probe, so add them explicitly).
+  roleSources: [.../* @__PURE__ */ new Set(["[role]", "input", "select", ...Object.keys(TAG_TO_ROLE)])].join(",")
 };
-/**
- * ARIA snapshot that tolerates every Playwright version the reporter supports,
- * returning null instead of throwing so a capture can never fail the test. The
- * options validator runs client-side in the user's installed Playwright, so an
- * unsupported key surfaces as a rejected promise (not a synchronous throw):
- *   - ≥ 1.59: `mode: 'ai'` yields the ref-annotated AI snapshot (the ideal);
- *     `ref` is unknown and silently stripped.
- *   - 1.52: `mode: 'ai'` fails validation (only 'raw'/'regex' are accepted) and
- *     rejects; the `{ ref: true }` fallback then yields a ref-annotated snapshot.
- *   - 1.53–1.58: neither `ref` nor `mode` exists — unknown keys are stripped
- *     server-side, so the first call already returns a plain flat snapshot.
- *   - < 1.49: `locator.ariaSnapshot` does not exist — returns null up front.
- */
 async function ariaSnapshotBestEffort(target, timeout) {
-    // Playwright < 1.49 predates locator.ariaSnapshot entirely.
-    if (typeof target.ariaSnapshot !== 'function')
-        return null;
+  if (typeof target.ariaSnapshot !== "function") return null;
+  try {
+    return await target.ariaSnapshot({
+      ...timeout != null ? { timeout } : {},
+      mode: "ai"
+    });
+  } catch {
     try {
-        return await target.ariaSnapshot({
-            ...(timeout != null ? { timeout } : {}),
-            mode: 'ai',
-        });
-    }
-    catch {
-        // 1.52 rejects `mode: 'ai'`; retry with the `ref` flag that release accepts.
-        try {
-            return await target.ariaSnapshot({
-                ...(timeout != null ? { timeout } : {}),
-                ref: true,
-            });
-        }
-        catch {
-            return null;
-        }
+      return await target.ariaSnapshot({
+        ...timeout != null ? { timeout } : {},
+        ref: true
+      });
+    } catch {
+      return null;
     }
+  }
 }
-/**
- * Runs inside the browser via `evaluate()` — probes a captured element for its
- * attributes, geometry, label association, and selector-uniqueness counts.
- * Must stay a fully self-contained function (no references to this module's
- * closure): Playwright serializes it and executes it in the page, browser-side.
- * `el` is browser-context (no DOM lib in this Node package), hence `any`.
- * Exported for unit testing; still passed directly to `evaluate()` below.
- */
 function probeElementAttrs(el, arg) {
-    const { keep, tagRoles, inputRoles, roleSources } = arg;
-    const attrMap = {};
-    for (const key of keep) {
-        const v = el.getAttribute(key) ?? el[key];
-        attrMap[key] = typeof v === 'string' ? v.slice(0, 200) : v ? String(v).slice(0, 200) : null;
+  const { keep, tagRoles, inputRoles, roleSources } = arg;
+  const attrMap = {};
+  for (const key of keep) {
+    const v = el.getAttribute(key) ?? el[key];
+    attrMap[key] = typeof v === "string" ? v.slice(0, 200) : v ? String(v).slice(0, 200) : null;
+  }
+  const r = el.getBoundingClientRect();
+  const selectorCounts = {};
+  try {
+    const doc = el.ownerDocument;
+    const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+    const count = (sel) => {
+      try {
+        return doc.querySelectorAll(sel).length;
+      } catch {
+        return void 0;
+      }
+    };
+    if (attrMap["data-testid"]) {
+      selectorCounts.testId = count(`[data-testid=${JSON.stringify(attrMap["data-testid"])}]`);
     }
-    const r = el.getBoundingClientRect();
-    // Uniqueness probe: how many elements each candidate selector matches. A
-    // count > 1 marks the alternative as ambiguous (strict-mode violation) so
-    // generateAlternatives drops it. All DOM/CSS access goes through `el` (no
-    // DOM lib here).
-    const selectorCounts = {};
-    try {
-        const doc = el.ownerDocument;
-        const cssEsc = (s) => doc.defaultView.CSS.escape(s);
-        const count = (sel) => {
-            try {
-                return doc.querySelectorAll(sel).length;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        if (attrMap['data-testid']) {
-            selectorCounts.testId = count(`[data-testid=${JSON.stringify(attrMap['data-testid'])}]`);
+    if (attrMap["id"]) selectorCounts.id = count(`#${cssEsc(attrMap["id"])}`);
+    if (attrMap["name"]) selectorCounts.name = count(`[name=${JSON.stringify(attrMap["name"])}]`);
+    const classList = (attrMap["class"] || "").split(/\s+/).filter((c) => c.length > 1).slice(0, 10);
+    if (classList.length > 0) {
+      const classCounts = {};
+      for (const cls of classList) {
+        const n = count(`.${cssEsc(cls)}`);
+        if (n !== void 0) classCounts[cls] = n;
+      }
+      selectorCounts.classes = classCounts;
+    }
+  } catch {
+  }
+  let rolePosition = null;
+  const ancestors = [];
+  try {
+    const doc = el.ownerDocument;
+    const cssEsc = (s) => doc.defaultView.CSS.escape(s);
+    const count = (sel) => {
+      try {
+        return doc.querySelectorAll(sel).length;
+      } catch {
+        return void 0;
+      }
+    };
+    const roleOf = (n) => {
+      const explicit = n.getAttribute("role");
+      if (explicit) return explicit;
+      const tag = (n.tagName || "").toLowerCase();
+      if (tag === "input") return inputRoles[(n.getAttribute("type") || "text").toLowerCase()] ?? "textbox";
+      if (tag === "select") return n.getAttribute("multiple") != null ? "listbox" : "combobox";
+      if (tag === "a") return n.getAttribute("href") != null ? "link" : null;
+      return tagRoles[tag] ?? null;
+    };
+    const levelOf = (n) => {
+      const m = /^h([1-6])$/.exec((n.tagName || "").toLowerCase());
+      if (m) return Number(m[1]);
+      const al = n.getAttribute("aria-level");
+      return al && /^\d+$/.test(al) ? Number(al) : null;
+    };
+    const targetRole = roleOf(el);
+    const targetLevel = targetRole === "heading" ? levelOf(el) : null;
+    if (targetRole) {
+      const nodes = doc.querySelectorAll(roleSources);
+      if (nodes.length <= 4e3) {
+        let roleCountAll = 0;
+        let index = -1;
+        let levelCount = 0;
+        for (let i = 0; i < nodes.length; i++) {
+          const n = nodes[i];
+          if (roleOf(n) !== targetRole) continue;
+          if (n === el) index = roleCountAll;
+          roleCountAll++;
+          if (targetLevel != null && levelOf(n) === targetLevel) levelCount++;
         }
-        if (attrMap['id'])
-            selectorCounts.id = count(`#${cssEsc(attrMap['id'])}`);
-        if (attrMap['name'])
-            selectorCounts.name = count(`[name=${JSON.stringify(attrMap['name'])}]`);
-        const classList = (attrMap['class'] || '')
-            .split(/\s+/)
-            .filter((c) => c.length > 1)
-            .slice(0, 10);
-        if (classList.length > 0) {
-            const classCounts = {};
-            for (const cls of classList) {
-                const n = count(`.${cssEsc(cls)}`);
-                if (n !== undefined)
-                    classCounts[cls] = n;
-            }
-            selectorCounts.classes = classCounts;
+        if (index !== -1) {
+          rolePosition = {
+            role: targetRole,
+            count: roleCountAll,
+            index,
+            ...targetLevel != null ? { levelCount } : {}
+          };
         }
-    }
-    catch {
-        // Uniqueness probing is best-effort — never fail the capture.
-    }
-    // Structural probe: the element's position among same-role elements plus
-    // anchor-worthy ancestors — powers name-free and ancestor-scoped
-    // alternatives that survive accessible-name renames. Role resolution reuses
-    // the shared maps passed in via `arg` (see roleOf below).
-    let rolePosition = null;
-    const ancestors = [];
-    try {
-        const doc = el.ownerDocument;
-        const cssEsc = (s) => doc.defaultView.CSS.escape(s);
-        const count = (sel) => {
-            try {
-                return doc.querySelectorAll(sel).length;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        // Role resolution on live DOM nodes, mirroring the Node-side resolveAriaRole
-        // branching. The role maps are passed in (arg.tagRoles/inputRoles) so this
-        // serialized-into-page function shares the single source of truth in
-        // locator-healing.ts rather than re-declaring it.
-        const roleOf = (n) => {
-            const explicit = n.getAttribute('role');
-            if (explicit)
-                return explicit;
-            const tag = (n.tagName || '').toLowerCase();
-            if (tag === 'input')
-                return inputRoles[(n.getAttribute('type') || 'text').toLowerCase()] ?? 'textbox';
-            if (tag === 'select')
-                return n.getAttribute('multiple') != null ? 'listbox' : 'combobox';
-            if (tag === 'a')
-                return n.getAttribute('href') != null ? 'link' : null;
-            return tagRoles[tag] ?? null;
-        };
-        const levelOf = (n) => {
-            const m = /^h([1-6])$/.exec((n.tagName || '').toLowerCase());
-            if (m)
-                return Number(m[1]);
-            const al = n.getAttribute('aria-level');
-            return al && /^\d+$/.test(al) ? Number(al) : null;
+        const CONTAINER_TAGS = ["form", "nav", "main", "article", "section", "dialog", "table"];
+        const docRoleCount = (role) => {
+          let c = 0;
+          for (let i = 0; i < nodes.length; i++) if (roleOf(nodes[i]) === role) c++;
+          return c;
         };
-        const targetRole = roleOf(el);
-        const targetLevel = targetRole === 'heading' ? levelOf(el) : null;
-        if (targetRole) {
-            const nodes = doc.querySelectorAll(roleSources);
-            // A truncated scan would produce wrong counts/indexes — skip instead.
-            if (nodes.length <= 4000) {
-                let roleCountAll = 0;
-                let index = -1;
-                let levelCount = 0;
-                for (let i = 0; i < nodes.length; i++) {
-                    const n = nodes[i];
-                    if (roleOf(n) !== targetRole)
-                        continue;
-                    if (n === el)
-                        index = roleCountAll;
-                    roleCountAll++;
-                    if (targetLevel != null && levelOf(n) === targetLevel)
-                        levelCount++;
-                }
-                if (index !== -1) {
-                    rolePosition = {
-                        role: targetRole,
-                        count: roleCountAll,
-                        index,
-                        ...(targetLevel != null ? { levelCount } : {}),
-                    };
-                }
-                // Anchor-worthy ancestors: a stable hook (test id, id, explicit role,
-                // aria-label) or a container/landmark tag, nearest first. Counts are
-                // computed here so alternative generation never guesses uniqueness.
-                const CONTAINER_TAGS = ['form', 'nav', 'main', 'article', 'section', 'dialog', 'table'];
-                const docRoleCount = (role) => {
-                    let c = 0;
-                    for (let i = 0; i < nodes.length; i++)
-                        if (roleOf(nodes[i]) === role)
-                            c++;
-                    return c;
-                };
-                let node = el.parentElement;
-                let depth = 0;
-                while (node && depth < 12 && ancestors.length < 4) {
-                    depth++;
-                    const tag = (node.tagName || '').toLowerCase();
-                    if (tag === 'body' || tag === 'html')
-                        break;
-                    const testId = node.getAttribute('data-testid');
-                    const id = node.getAttribute('id');
-                    const explicitRole = node.getAttribute('role');
-                    const ariaLabel = node.getAttribute('aria-label');
-                    const anchorRole = explicitRole || (CONTAINER_TAGS.includes(tag) ? tagRoles[tag] : null) || null;
-                    if (testId || id || anchorRole || ariaLabel) {
-                        // The leaf-role match count within this ancestor (level-scoped for
-                        // headings — the emitted chained locator is level-scoped too).
-                        const scoped = node.querySelectorAll(roleSources);
-                        let scopedRoleCount = 0;
-                        if (scoped.length <= 2000) {
-                            for (let i = 0; i < scoped.length; i++) {
-                                const n = scoped[i];
-                                if (roleOf(n) !== targetRole)
-                                    continue;
-                                if (targetLevel != null && levelOf(n) !== targetLevel)
-                                    continue;
-                                scopedRoleCount++;
-                            }
-                        }
-                        else {
-                            scopedRoleCount = -1; // truncated — unusable
-                        }
-                        ancestors.push({
-                            tag,
-                            depth,
-                            testId: testId || null,
-                            id: id || null,
-                            role: explicitRole || null,
-                            ariaLabel: ariaLabel || null,
-                            ...(scopedRoleCount >= 0 ? { scopedRoleCount } : {}),
-                            ...(testId ? { testIdCount: count(`[data-testid=${JSON.stringify(testId)}]`) } : {}),
-                            ...(id ? { idCount: count(`#${cssEsc(id)}`) } : {}),
-                            ...(anchorRole ? { roleCount: docRoleCount(anchorRole) } : {}),
-                        });
-                    }
-                    node = node.parentElement;
-                }
+        let node = el.parentElement;
+        let depth = 0;
+        while (node && depth < 12 && ancestors.length < 4) {
+          depth++;
+          const tag = (node.tagName || "").toLowerCase();
+          if (tag === "body" || tag === "html") break;
+          const testId = node.getAttribute("data-testid");
+          const id = node.getAttribute("id");
+          const explicitRole = node.getAttribute("role");
+          const ariaLabel = node.getAttribute("aria-label");
+          const anchorRole = explicitRole || (CONTAINER_TAGS.includes(tag) ? tagRoles[tag] : null) || null;
+          if (testId || id || anchorRole || ariaLabel) {
+            const scoped = node.querySelectorAll(roleSources);
+            let scopedRoleCount = 0;
+            if (scoped.length <= 2e3) {
+              for (let i = 0; i < scoped.length; i++) {
+                const n = scoped[i];
+                if (roleOf(n) !== targetRole) continue;
+                if (targetLevel != null && levelOf(n) !== targetLevel) continue;
+                scopedRoleCount++;
+              }
+            } else {
+              scopedRoleCount = -1;
             }
+            ancestors.push({
+              tag,
+              depth,
+              testId: testId || null,
+              id: id || null,
+              role: explicitRole || null,
+              ariaLabel: ariaLabel || null,
+              ...scopedRoleCount >= 0 ? { scopedRoleCount } : {},
+              ...testId ? { testIdCount: count(`[data-testid=${JSON.stringify(testId)}]`) } : {},
+              ...id ? { idCount: count(`#${cssEsc(id)}`) } : {},
+              ...anchorRole ? { roleCount: docRoleCount(anchorRole) } : {}
+            });
+          }
+          node = node.parentElement;
         }
+      }
     }
-    catch {
-        // Structural probing is best-effort — never fail the capture.
-    }
-    return {
-        tagName: el.tagName?.toLowerCase?.() ?? 'unknown',
-        attributes: attrMap,
-        // Collapse whitespace so multi-line text can't produce a getByText
-        // suggestion with literal newlines in it.
-        textContent: (el.textContent || '').replace(/\s+/g, ' ').trim().slice(0, 80),
-        center: {
-            x: Math.round(r.x + r.width / 2),
-            y: Math.round(r.y + r.height / 2),
-        },
-        hasLabel: !!(el.labels && el.labels.length > 0),
-        selectorCounts,
-        rolePosition,
-        ancestors,
-    };
+  } catch {
+  }
+  return {
+    tagName: el.tagName?.toLowerCase?.() ?? "unknown",
+    attributes: attrMap,
+    // Collapse whitespace so multi-line text can't produce a getByText
+    // suggestion with literal newlines in it.
+    textContent: (el.textContent || "").replace(/\s+/g, " ").trim().slice(0, 80),
+    center: {
+      x: Math.round(r.x + r.width / 2),
+      y: Math.round(r.y + r.height / 2)
+    },
+    hasLabel: !!(el.labels && el.labels.length > 0),
+    selectorCounts,
+    rolePosition,
+    ancestors
+  };
 }
-// Chain methods that take args and define a new locator scope (not just narrow).
-// Origin method/args update to the chain call, e.g. .locator('.item') → locator('.item').
-// Positional/filter chains that narrow but don't change locator identity.
-// Origin stays from the page-level call, e.g. .first(), .nth(2), .filter(...).
 function wrapLocator(page, locator, originMethod, originArgs) {
-    return new Proxy(locator, {
-        get(target, prop) {
-            const original = Reflect.get(target, prop);
-            if (typeof original !== 'function')
-                return original;
-            const fn = original;
-            if (CHAIN_METHOD_SET.has(prop)) {
-                return (...args) => {
-                    const next = fn.apply(target, args);
-                    if (locator_healing_js_1.LOCATOR_CREATING_CHAINS.has(prop)) {
-                        return wrapLocator(page, next, String(prop), args);
-                    }
-                    return wrapLocator(page, next, originMethod, originArgs);
-                };
-            }
-            if (!ACTION_METHOD_SET.has(prop))
-                return original;
-            return async (...callArgs) => {
-                // Bind to the sink active when the action starts so the async element
-                // capture below writes back to the right test even across a boundary.
-                const sink = currentSink;
-                // Action outside a tracked test (e.g. during beforeAll) — run untouched.
-                if (!sink)
-                    return fn.apply(target, callArgs);
-                sink.lastActivePage = page;
-                const seq = sink.capturedLocators.length;
-                // Capture the test call-site now (sync) so the snapshot's location
-                // matches the error stack's first user frame — independent of
-                // pw:api step ordering, worker interleaving, or concurrent actions.
-                const callerLocation = (0, locator_healing_js_1.captureCallerLocation)();
-                // Built once, shared by the placeholder and the resolved snapshot below.
-                const used = {
-                    method: originMethod,
-                    args: originArgs,
-                    raw: `${originMethod}(${JSON.stringify(originArgs)})`,
-                };
-                // Push a placeholder immediately — DOM capture runs async below
-                sink.capturedLocators.push({
-                    location: callerLocation,
-                    used,
-                    element: null,
-                    alternatives: [],
-                });
-                // The placeholder is already pushed. If the action throws, record the
-                // failed locator (so teardown can suggest a fresh one for the element's
-                // current identity) and re-throw so the test still fails.
-                let result;
-                try {
-                    result = await fn.apply(target, callArgs);
-                }
-                catch (error) {
-                    sink.failedLocators.push({ method: originMethod, args: originArgs });
-                    throw error;
-                }
-                // Fire-and-forget: capture element data without blocking the test. The
-                // snapshot wait below is bounded by a 500ms deadline (evaluate can hang
-                // when the page navigates), but the probe's underlying protocol call is
-                // tracked in PENDING_PROBES so the close wrappers can drain it — and in
-                // capturePromises so flushSink outwaits it — even when the deadline
-                // abandons it. An evaluate still in flight when its page closes crashes
-                // the connection dispatcher with a global "not bound" error.
-                const probe = target.evaluate(probeElementAttrs, exports.CAPTURED_ATTRS_ARG);
-                const settledProbe = probe.then(() => undefined, () => undefined);
-                PENDING_PROBES.add(settledProbe);
-                settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
-                sink.capturePromises.push(settledProbe);
-                const resolveAttrs = (async () => {
-                    let deadline;
-                    try {
-                        const attrs = await Promise.race([
-                            probe,
-                            new Promise((_, reject) => {
-                                deadline = setTimeout(() => reject(new Error('locator capture timeout')), 500);
-                            }),
-                        ]);
-                        // The browser-computed accessible name only feeds role-based and
-                        // form-field alternatives, so only pay for the extra ARIA
-                        // snapshot when the element actually has a role or is a field.
-                        const role = (0, locator_healing_js_1.resolveAriaRole)({ ...attrs, accessibleName: null });
-                        const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
-                        // Bound with a timeout: without it, ariaSnapshot waits up to the
-                        // test timeout when the page is mid-navigation, which hangs the
-                        // teardown that drains these capture promises.
-                        // ariaSnapshotBestEffort adapts the options to the installed
-                        // Playwright version and never throws (see its doc comment).
-                        const aria = role || isFormField ? await ariaSnapshotBestEffort(target, 500) : null;
-                        const accessibleName = (0, locator_healing_js_1.extractAccessibleName)(aria) || (0, locator_healing_js_1.approximateAccessibleName)({ ...attrs, accessibleName: null });
-                        sink.capturedLocators[seq] = {
-                            location: callerLocation,
-                            used,
-                            // hasLabel/selectorCounts inform alternative generation only —
-                            // keep the stored element to the wire shape. rolePosition and
-                            // ancestors ARE wire fields: the server's renamed-element match
-                            // uses them at heal time.
-                            element: {
-                                tagName: attrs.tagName,
-                                attributes: attrs.attributes,
-                                textContent: attrs.textContent,
-                                accessibleName,
-                                center: attrs.center,
-                                ...(attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {}),
-                                ...(attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}),
-                            },
-                            alternatives: (0, locator_healing_js_1.generateAlternatives)({ ...attrs, accessibleName }),
-                        };
-                    }
-                    catch {
-                        // element detached or timeout — keep the placeholder
-                    }
-                    finally {
-                        clearTimeout(deadline);
-                    }
-                })();
-                sink.capturePromises.push(resolveAttrs);
-                return result;
+  return new Proxy(locator, {
+    get(target, prop) {
+      const original = Reflect.get(target, prop);
+      if (typeof original !== "function") return original;
+      const fn = original;
+      if (CHAIN_METHOD_SET.has(prop)) {
+        return (...args) => {
+          const next = fn.apply(target, args);
+          if (LOCATOR_CREATING_CHAINS.has(prop)) {
+            return wrapLocator(page, next, String(prop), args);
+          }
+          return wrapLocator(page, next, originMethod, originArgs);
+        };
+      }
+      if (!ACTION_METHOD_SET.has(prop)) return original;
+      return async (...callArgs) => {
+        const sink = currentSink;
+        if (!sink) return fn.apply(target, callArgs);
+        sink.lastActivePage = page;
+        const seq = sink.capturedLocators.length;
+        const callerLocation = captureCallerLocation();
+        const used = {
+          method: originMethod,
+          args: originArgs,
+          raw: `${originMethod}(${JSON.stringify(originArgs)})`
+        };
+        sink.capturedLocators.push({
+          location: callerLocation,
+          used,
+          element: null,
+          alternatives: []
+        });
+        let result;
+        try {
+          result = await fn.apply(target, callArgs);
+        } catch (error) {
+          sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
+          throw error;
+        }
+        const probe = target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG);
+        const settledProbe = probe.then(
+          () => void 0,
+          () => void 0
+        );
+        PENDING_PROBES.add(settledProbe);
+        settledProbe.then(() => PENDING_PROBES.delete(settledProbe));
+        sink.capturePromises.push(settledProbe);
+        const resolveAttrs = (async () => {
+          let deadline;
+          try {
+            const attrs = await Promise.race([
+              probe,
+              new Promise((_, reject) => {
+                deadline = setTimeout(() => reject(new Error("locator capture timeout")), 500);
+              })
+            ]);
+            const role = resolveAriaRole({ ...attrs, accessibleName: null });
+            const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
+            const aria = role || isFormField ? await ariaSnapshotBestEffort(target, 500) : null;
+            const accessibleName = extractAccessibleName(aria) || approximateAccessibleName({ ...attrs, accessibleName: null });
+            sink.capturedLocators[seq] = {
+              location: callerLocation,
+              used,
+              // hasLabel/selectorCounts inform alternative generation only —
+              // keep the stored element to the wire shape. rolePosition and
+              // ancestors ARE wire fields: the server's renamed-element match
+              // uses them at heal time.
+              element: {
+                tagName: attrs.tagName,
+                attributes: attrs.attributes,
+                textContent: attrs.textContent,
+                accessibleName,
+                center: attrs.center,
+                ...attrs.rolePosition ? { rolePosition: attrs.rolePosition } : {},
+                ...attrs.ancestors && attrs.ancestors.length > 0 ? { ancestors: attrs.ancestors } : {}
+              },
+              alternatives: generateAlternatives({ ...attrs, accessibleName })
             };
-        },
-    });
+          } catch {
+          } finally {
+            clearTimeout(deadline);
+          }
+        })();
+        sink.capturePromises.push(resolveAttrs);
+        return result;
+      };
+    }
+  });
 }
-/**
- * Instrument a single page: wrap its locator-building methods for healing
- * capture and attach console/network listeners. Idempotent — safe to call on a
- * page already reached through another path (browser patch, `page` fixture).
- */
 function instrumentPage(page) {
-    if (!page || INSTRUMENTED_PAGES.has(page))
-        return;
-    INSTRUMENTED_PAGES.add(page);
-    // A page reached through the `page` fixture safety net may live in a context
-    // the browser patch never saw — instrument it so its close is wrapped too.
-    const ctx = pageContext(page);
-    if (ctx)
-        instrumentContext(ctx);
-    // Drain in-flight probes before a user-initiated close (the guard tolerates
-    // page-like test fakes without a close method), and preserve the
-    // page-dependent teardown reads while the page can still serve them.
-    if (typeof page.close === 'function') {
-        const originalClose = page.close.bind(page);
-        page.close = async (...args) => {
-            await drainPendingProbes(1000);
-            const sink = currentSink;
-            if (sink)
-                await stashPageState(sink, { page });
-            return originalClose(...args);
-        };
+  if (!page || INSTRUMENTED_PAGES.has(page)) return;
+  INSTRUMENTED_PAGES.add(page);
+  const ctx = pageContext(page);
+  if (ctx) instrumentContext(ctx);
+  if (typeof page.close === "function") {
+    const originalClose = page.close.bind(page);
+    page.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      const sink = currentSink;
+      if (sink) {
+        await stashPageState(sink, { page });
+        await maybeOpenPicker(sink, { page });
+      }
+      return originalClose(...args);
+    };
+  }
+  const captureLocators = process.env.PIWI_CAPTURE_LOCATORS !== "false";
+  if (captureLocators) {
+    const factories = page;
+    for (const method of LOCATOR_METHODS) {
+      const original = factories[method].bind(page);
+      factories[method] = (...args) => {
+        if (currentSink) currentSink.lastActivePage = page;
+        return wrapLocator(page, original(...args), method, args);
+      };
     }
-    // Opt-out: skipped when PIWI_CAPTURE_LOCATORS=false (set automatically when
-    // the reporter's collectPerformanceMetrics / captureLocators is disabled),
-    // so the per-action DOM read + ARIA snapshot cost is never paid when unused.
-    const captureLocators = process.env.PIWI_CAPTURE_LOCATORS !== 'false';
-    if (captureLocators) {
-        // Locator factories are accessed by dynamic name, so a string-indexed view
-        // of the page is the cleanest local escape hatch from the static surface.
-        const factories = page;
-        for (const method of locator_healing_js_1.LOCATOR_METHODS) {
-            const original = factories[method].bind(page);
-            factories[method] = (...args) => {
-                // Touching a page's locator factory marks it the active page even for
-                // assertion-only tests that never call an action method.
-                if (currentSink)
-                    currentSink.lastActivePage = page;
-                return wrapLocator(page, original(...args), method, args);
-            };
-        }
+  }
+  page.on("console", (msg) => {
+    const sink = currentSink;
+    if (!sink) return;
+    const type = msg.type();
+    if (["warning", "error", "assert"].includes(type)) {
+      const location = msg.location();
+      sink.consoleEntries.push({
+        type,
+        text: msg.text(),
+        timestamp: Date.now(),
+        location: location ? `${location.url}:${location.lineNumber}:${location.columnNumber}` : null
+      });
     }
-    page.on('console', (msg) => {
-        const sink = currentSink;
-        if (!sink)
-            return;
-        const type = msg.type();
-        if (['warning', 'error', 'assert'].includes(type)) {
-            const location = msg.location();
-            sink.consoleEntries.push({
-                type,
-                text: msg.text(),
-                timestamp: Date.now(),
-                location: location ? `${location.url}:${location.lineNumber}:${location.columnNumber}` : null,
-            });
-        }
-    });
-    page.on('requestfinished', (request) => {
-        const sink = currentSink;
-        if (!sink)
-            return;
-        sink.lastActivePage = page;
-        const p = (async () => {
+  });
+  page.on("requestfinished", (request) => {
+    const sink = currentSink;
+    if (!sink) return;
+    sink.lastActivePage = page;
+    const p = (async () => {
+      try {
+        const url = request.url();
+        if (url.startsWith("data:") || url.startsWith("blob:")) return;
+        const timing = request.timing();
+        const response = await request.response();
+        const resourceType = request.resourceType();
+        if (!["fetch", "xhr", "document", "other"].includes(resourceType)) return;
+        const entry = {
+          method: request.method(),
+          url,
+          status: response ? response.status() : 0,
+          duration: timing.responseEnd > 0 ? Math.round(timing.responseEnd - timing.requestStart) : 0,
+          startTime: timing.startTime,
+          resourceType
+        };
+        if (response) {
+          const headers = response.headers();
+          const contentType = headers["content-type"];
+          if (contentType) entry.contentType = contentType.split(";")[0].trim();
+          const logHeader = headers["x-piwi-logs"];
+          if (logHeader) {
             try {
-                const url = request.url();
-                if (url.startsWith('data:') || url.startsWith('blob:'))
-                    return;
-                const timing = request.timing();
-                const response = await request.response();
-                const resourceType = request.resourceType();
-                // Only keep API/document requests; skip static assets (scripts, styles, fonts, images, media)
-                if (!['fetch', 'xhr', 'document', 'other'].includes(resourceType))
-                    return;
-                const entry = {
-                    method: request.method(),
-                    url,
-                    status: response ? response.status() : 0,
-                    duration: timing.responseEnd > 0 ? Math.round(timing.responseEnd - timing.requestStart) : 0,
-                    startTime: timing.startTime,
-                    resourceType,
-                };
-                if (response) {
-                    const headers = response.headers();
-                    // Response content type (without charset/boundary params) — relevant
-                    // per-request metadata for distinguishing API/JSON vs document/HTML calls.
-                    const contentType = headers['content-type'];
-                    if (contentType)
-                        entry.contentType = contentType.split(';')[0].trim();
-                    const logHeader = headers['x-piwi-logs'];
-                    if (logHeader) {
-                        try {
-                            entry.serverLogs = JSON.parse((0, node_zlib_1.gunzipSync)(Buffer.from(logHeader, 'base64')).toString('utf-8'));
-                        }
-                        catch {
-                            /* ignore malformed header */
-                        }
-                    }
-                }
-                sink.networkRequests.push(entry);
-            }
-            catch {
-                /* ignore */
+              entry.serverLogs = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+            } catch {
             }
-        })();
-        sink.pendingHandlers.push(p);
-    });
+          }
+        }
+        sink.networkRequests.push(entry);
+      } catch {
+      }
+    })();
+    sink.pendingHandlers.push(p);
+  });
 }
-/**
- * Instrument a browser context so every page it opens — via `newPage()` or as a
- * popup/`window.open` — is captured. Idempotent.
- */
 function instrumentContext(context) {
-    if (!context || INSTRUMENTED_CONTEXTS.has(context))
-        return;
-    INSTRUMENTED_CONTEXTS.add(context);
-    const originalNewPage = context.newPage.bind(context);
-    context.newPage = async (...args) => {
-        const page = await originalNewPage(...args);
-        instrumentPage(page);
-        return page;
+  if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
+  INSTRUMENTED_CONTEXTS.add(context);
+  const originalNewPage = context.newPage.bind(context);
+  context.newPage = async (...args) => {
+    const page = await originalNewPage(...args);
+    instrumentPage(page);
+    return page;
+  };
+  if (typeof context.close === "function") {
+    const originalClose = context.close.bind(context);
+    context.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      const sink = currentSink;
+      if (sink) {
+        await stashPageState(sink, { context });
+        await maybeOpenPicker(sink, { context });
+      }
+      return originalClose(...args);
     };
-    // The built-in context fixture closes here at test teardown — BEFORE the
-    // auto capture fixture flushes. Drain in-flight probes (an evaluate crossing
-    // the close crashes the connection with a global "not bound" error) and take
-    // the page-dependent reads (web vitals, failure ARIA snapshot) while the
-    // test's page is still open.
-    if (typeof context.close === 'function') {
-        const originalClose = context.close.bind(context);
-        context.close = async (...args) => {
-            await drainPendingProbes(1000);
-            const sink = currentSink;
-            if (sink)
-                await stashPageState(sink, { context });
-            return originalClose(...args);
-        };
-    }
-    // Popups and pages the context opens on its own (idempotent with the above).
-    context.on('page', (page) => instrumentPage(page));
+  }
+  context.on("page", (page) => instrumentPage(page));
 }
-/**
- * Patch a browser so any page or context created directly from it is
- * instrumented. This is what makes capture work for suites that build their own
- * pages from the worker-scoped `browser` (e.g. `browser.newPage()` /
- * `browser.newContext().newPage()`) instead of using the `page` fixture.
- * Idempotent.
- */
 function patchBrowser(browser) {
-    if (!browser || PATCHED_BROWSERS.has(browser))
-        return;
-    PATCHED_BROWSERS.add(browser);
-    const originalNewPage = browser.newPage.bind(browser);
-    browser.newPage = async (...args) => {
-        const page = await originalNewPage(...args);
-        instrumentPage(page);
-        return page;
+  if (!browser || PATCHED_BROWSERS.has(browser)) return;
+  PATCHED_BROWSERS.add(browser);
+  const originalNewPage = browser.newPage.bind(browser);
+  browser.newPage = async (...args) => {
+    const page = await originalNewPage(...args);
+    instrumentPage(page);
+    return page;
+  };
+  const originalNewContext = browser.newContext.bind(browser);
+  browser.newContext = async (...args) => {
+    const context = await originalNewContext(...args);
+    instrumentContext(context);
+    return context;
+  };
+  if (typeof browser.close === "function") {
+    const originalClose = browser.close.bind(browser);
+    browser.close = async (...args) => {
+      await drainPendingProbes(1e3);
+      return originalClose(...args);
     };
-    const originalNewContext = browser.newContext.bind(browser);
-    browser.newContext = async (...args) => {
-        const context = await originalNewContext(...args);
-        instrumentContext(context);
-        return context;
-    };
-    // Worker shutdown closes the browser; a probe still in flight would crash
-    // the connection dispatcher.
-    if (typeof browser.close === 'function') {
-        const originalClose = browser.close.bind(browser);
-        browser.close = async (...args) => {
-            await drainPendingProbes(1000);
-            return originalClose(...args);
-        };
-    }
+  }
 }
-/**
- * Drain in-flight capture work and attach the collected `piwi-*` data
- * to the test. Mirrors the per-test teardown the `page` fixture used to do, but
- * sourced from the sink so it works regardless of how the test's pages were made.
- */
 async function flushSink(sink, testInfo) {
-    // Wait for all in-flight requestfinished handlers before snapshotting
-    // networkRequests — the last request (often the one that failed the test)
-    // races with teardown and its serverLogs would otherwise be lost.
-    await Promise.allSettled(sink.pendingHandlers);
-    // ── Attach locator snapshots ──────────────────────────────────────────
-    // Cap the drain so a stuck capture (e.g. a navigation in flight) can never
-    // hang teardown past the test timeout; per-action evaluate/ariaSnapshot are
-    // already bounded, this is a backstop.
-    let drainDeadline;
-    await Promise.race([
-        Promise.allSettled(sink.capturePromises),
-        new Promise((resolve) => {
-            drainDeadline = setTimeout(resolve, 2000);
-        }),
-    ]);
-    clearTimeout(drainDeadline);
-    if (sink.capturedLocators.length > 0) {
-        await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.locators, {
-            contentType: 'application/json',
-            // Repeated call sites (loops) keep only their latest capture — the
-            // server stores one row per location anyway, so shipping every
-            // iteration is pure payload bloat.
-            body: Buffer.from(JSON.stringify((0, locator_healing_js_1.dedupeSnapshotsByLocation)(sink.capturedLocators))),
+  await Promise.allSettled(sink.pendingHandlers);
+  let drainDeadline;
+  await Promise.race([
+    Promise.allSettled(sink.capturePromises),
+    new Promise((resolve) => {
+      drainDeadline = setTimeout(resolve, 2e3);
+    })
+  ]);
+  clearTimeout(drainDeadline);
+  const page = sink.lastActivePage;
+  const pageReadable = page !== null && !isPageClosed(page);
+  if (pageReadable) await maybeOpenPicker(sink);
+  if (sink.capturedLocators.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.locators, {
+      contentType: "application/json",
+      // Repeated call sites (loops) keep only their latest capture — the
+      // server stores one row per location anyway, so shipping every
+      // iteration is pure payload bloat.
+      body: Buffer.from(JSON.stringify(dedupeSnapshotsByLocation(sink.capturedLocators)))
+    });
+  }
+  if (testInfo.status !== "passed" && testInfo.status !== "skipped") {
+    try {
+      const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(":root")) : null) ?? sink.stashedAria;
+      if (snapshot) {
+        await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
+          contentType: "text/plain",
+          body: snapshot
         });
-    }
-    const page = sink.lastActivePage;
-    const pageReadable = page !== null && !isPageClosed(page);
-    if (testInfo.status !== 'passed' && testInfo.status !== 'skipped') {
-        try {
-            // Prefer a live read; fall back to the snapshot the close wrappers
-            // stashed — the standard test page is already closed when this auto
-            // fixture tears down.
-            const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(':root')) : null) ?? sink.stashedAria;
-            if (snapshot) {
-                await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.ariaSnapshot, {
-                    contentType: 'text/plain',
-                    body: snapshot,
-                });
-                // Suggest a fresh locator for the failed action from the current page.
-                // When the element was renamed/moved, the pre-captured alternatives
-                // describe the old element, so this points at where it went now — as a
-                // Playwright annotation (shown in the report + trace) and an attachment
-                // (shown in the trace viewer). It does NOT change the locator.
-                const failed = sink.failedLocators[sink.failedLocators.length - 1];
-                const suggestion = failed ? (0, locator_healing_js_1.suggestLocatorsFromAria)(failed, snapshot) : null;
-                if (suggestion) {
-                    testInfo.annotations.push({
-                        type: attachments_js_1.LOCATOR_SUGGESTION_ANNOTATION,
-                        description: `${suggestion.failing} matched nothing on the failing page — the element may have been renamed or moved. Suggested: ${suggestion.suggestions.join('  |  ')}`,
-                    });
-                    await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.locatorSuggestion, {
-                        contentType: 'application/json',
-                        body: Buffer.from(JSON.stringify(suggestion)),
-                    });
-                }
-            }
+        const failed = sink.failedLocators[sink.failedLocators.length - 1];
+        const suggestion = failed ? suggestLocatorsFromAria(failed, snapshot) : null;
+        if (suggestion) {
+          testInfo.annotations.push({
+            type: LOCATOR_SUGGESTION_ANNOTATION,
+            description: `${suggestion.failing} matched nothing on the failing page \u2014 the element may have been renamed or moved. Suggested: ${suggestion.suggestions.join("  |  ")}`
+          });
+          await testInfo.attach(ATTACHMENT_NAMES.locatorSuggestion, {
+            contentType: "application/json",
+            body: Buffer.from(JSON.stringify(suggestion))
+          });
         }
-        catch {
-            /* ignore */
-        }
-    }
-    if (sink.consoleEntries.length > 0) {
-        await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.console, {
-            contentType: 'application/json',
-            body: Buffer.from(JSON.stringify(sink.consoleEntries)),
-        });
+      }
+    } catch {
     }
-    if (sink.networkRequests.length > 0) {
-        await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.network, {
-            contentType: 'application/json',
-            body: Buffer.from(JSON.stringify(sink.networkRequests)),
-        });
-    }
-    // Live read when the page still exists (e.g. a browser.newPage the test left
-    // open); otherwise the vitals the close wrappers stashed before the page went.
-    const webVitals = (pageReadable ? await readWebVitals(page) : null) ?? sink.stashedWebVitals;
-    if (webVitals) {
-        await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.webVitals, {
-            contentType: 'application/json',
-            body: Buffer.from(JSON.stringify(webVitals)),
-        });
+  }
+  if (sink.userPick) {
+    const pick = sink.userPick;
+    testInfo.annotations.push({
+      type: USER_PICK_ANNOTATION,
+      description: pick.failing ? `Replacement locator picked on the failing page for ${pick.failing.rendered}${pick.failing.location ? ` at ${pick.failing.location}` : ""}: ${pick.picked.locator}` : `Locator picked while inspecting the failing page: ${pick.picked.locator}`
+    });
+    try {
+      await testInfo.attach(ATTACHMENT_NAMES.userPick, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(pick))
+      });
+    } catch {
     }
-    // Page state at test end (pass AND fail — the pass side is the diff baseline).
-    if (process.env.PIWI_CAPTURE_PAGE_STATE !== 'false') {
-        const pageState = (pageReadable ? await readPageState(page) : null) ?? sink.stashedPageState;
-        if (pageState) {
-            await testInfo.attach(attachments_js_1.ATTACHMENT_NAMES.pageState, {
-                contentType: 'application/json',
-                body: Buffer.from(JSON.stringify(pageState)),
-            });
-        }
+  } else if (!sink.pickOffered) {
+    const reason = environmentalSkipReason(inspectionGateFromTestInfo(testInfo, process.env.PIWI_PICK_LOCATOR_ON_FAIL)) ?? environmentalSkipReason(inspectionGateFromTestInfo(testInfo));
+    if (reason) console.log(`[piwi] failure-time locator tools enabled but skipped: ${reason}`);
+  }
+  if (sink.consoleEntries.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.console, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.consoleEntries))
+    });
+  }
+  if (sink.networkRequests.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.network, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.networkRequests))
+    });
+  }
+  const webVitals = (pageReadable ? await readWebVitals(page) : null) ?? sink.stashedWebVitals;
+  if (webVitals) {
+    await testInfo.attach(ATTACHMENT_NAMES.webVitals, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(webVitals))
+    });
+  }
+  if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
+    const pageState = (pageReadable ? await readPageState(page) : null) ?? sink.stashedPageState;
+    if (pageState) {
+      await testInfo.attach(ATTACHMENT_NAMES.pageState, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(pageState))
+      });
     }
+  }
 }
-/**
- * Playwright fixtures that collect network requests, console entries,
- * web vitals, ARIA snapshots, and locator interaction data during a test.
- *
- * Capture is wired at the `browser` level, so it works whether a test uses the
- * standard `page` fixture or builds its own pages from `browser` /
- * `browser.newContext()`. Collected data is attached as `piwi-*`
- * test-info attachments which the Piwi Dashboard reporter parses on `onTestEnd`.
- */
-exports.piwiFixtures = {
-    // Worker-scoped: patch the shared browser so every page/context created from
-    // it — including by user fixtures that take `browser` directly — is captured.
-    browser: [
-        async ({ browser }, use) => {
-            patchBrowser(browser);
-            await use(browser);
-        },
-        { scope: 'worker' },
-    ],
-    // Safety net for the standard `page` fixture, in case its page is created
-    // through an internal path the browser patch doesn't see. Idempotent, so it
-    // never double-wraps a page the browser patch already instrumented.
-    page: async ({ page }, use) => {
-        instrumentPage(page);
-        await use(page);
+var piwiFixtures = {
+  // Worker-scoped: patch the shared browser so every page/context created from
+  // it — including by user fixtures that take `browser` directly — is captured.
+  browser: [
+    async ({ browser }, use) => {
+      patchBrowser(browser);
+      await use(browser);
     },
-    // Auto, test-scoped: open a capture sink for the running test and flush it
-    // (attach the collected data) at teardown. Runs for every test without being
-    // requested, so suites that never destructure `page` are still captured.
-    piwiCapture: [
-        async ({}, use, testInfo) => {
-            const sink = createSink();
-            sink.testInfo = testInfo;
-            currentSink = sink;
-            try {
-                await use();
-            }
-            finally {
-                currentSink = null;
-                await flushSink(sink, testInfo);
-            }
-        },
-        { auto: true },
-    ],
+    { scope: "worker" }
+  ],
+  // Safety net for the standard `page` fixture, in case its page is created
+  // through an internal path the browser patch doesn't see. Idempotent, so it
+  // never double-wraps a page the browser patch already instrumented.
+  page: async ({ page }, use) => {
+    instrumentPage(page);
+    await use(page);
+  },
+  // Auto, test-scoped: open a capture sink for the running test and flush it
+  // (attach the collected data) at teardown. Runs for every test without being
+  // requested, so suites that never destructure `page` are still captured.
+  piwiCapture: [
+    async ({}, use, testInfo) => {
+      const sink = createSink();
+      sink.testInfo = testInfo;
+      currentSink = sink;
+      try {
+        await use();
+      } finally {
+        currentSink = null;
+        await flushSink(sink, testInfo);
+      }
+    },
+    { auto: true }
+  ]
 };
-/**
- * Extend a Playwright `test` object with the Piwi capture fixtures. The
- * returned `test` carries the existing fixtures plus {@link PiwiFixtures}.
- *
- * Use this instead of importing `@playwright/test` directly from this package
- * to avoid the "Requiring @playwright/test second time" error caused by
- * duplicate module resolution.
- *
- * @example
- * ```ts
- * import { test as base } from '@playwright/test';
- * import { extendPiwiFixtures } from '@piwitests/reporter';
- *
- * export const test = extendPiwiFixtures(base);
- * ```
- */
 function extendPiwiFixtures(test) {
-    return test.extend(exports.piwiFixtures);
+  return test.extend(piwiFixtures);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CAPTURED_ATTRS_ARG,
+  ariaSnapshotBestEffort,
+  buildPageState,
+  computeCoreVitals,
+  extendPiwiFixtures,
+  piwiFixtures,
+  probeElementAttrs
+});