@piwitests/reporter 0.39.0 → 0.41.0

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

@@ -31,20 +31,56 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var capture_fixtures_exports = {};
 __export(capture_fixtures_exports, {
   CAPTURED_ATTRS_ARG: () => CAPTURED_ATTRS_ARG,
+  LocatorPageLog: () => LocatorPageLog,
   ariaSnapshotBestEffort: () => ariaSnapshotBestEffort,
   ariaSnapshotJSONBestEffort: () => ariaSnapshotJSONBestEffort,
+  boxCaptureFrames: () => boxCaptureFrames,
   buildPageState: () => buildPageState,
+  callMethod: () => callMethod,
+  codeReachRoots: () => codeReachRoots,
   computeCoreVitals: () => computeCoreVitals,
+  configuredCodeReachRoots: () => configuredCodeReachRoots,
   extendPiwiFixtures: () => extendPiwiFixtures,
+  internalCall: () => internalCall,
+  noteLocatorCall: () => noteLocatorCall,
+  noteNavigation: () => noteNavigation,
+  pageMapFetcher: () => pageMapFetcher,
   piwiFixtures: () => piwiFixtures,
-  probeElementAttrs: () => probeElementAttrs
+  probeElementAttrs: () => probeElementAttrs,
+  resolveCodeReach: () => resolveCodeReach,
+  startCodeReach: () => startCodeReach,
+  stopCodeReach: () => stopCodeReach
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
+var path10 = __toESM(require("path"));
 var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
 function probeElementAttrs(el, arg) {
-  const { keep, tagRoles, inputRoles, roleSources, includeStructural, includeLabelText } = arg;
+  const { keep, tagRoles, inputRoles, roleSources, includeStructural } = arg;
+  const FIELD_TAGS = ["input", "select", "textarea"];
+  const textWithout = (root, skip) => {
+    if (root === skip) return "";
+    if (root.nodeType === 3) return root.nodeValue || "";
+    let text = "";
+    const kids = root.childNodes || [];
+    for (let i = 0; i < kids.length; i++) text += textWithout(kids[i], skip);
+    return text;
+  };
+  const labelTextOf = (n) => {
+    try {
+      const ids = (n.getAttribute("aria-labelledby") || "").split(/\s+/).filter(Boolean);
+      let text = "";
+      for (const id of ids) {
+        const ref = n.ownerDocument.getElementById(id);
+        if (ref) text += ` ${textWithout(ref, n)}`;
+      }
+      if (!text.trim() && n.labels && n.labels.length > 0) text = textWithout(n.labels[0], n);
+      return text.replace(/\s+/g, " ").trim().slice(0, 120) || null;
+    } catch {
+      return null;
+    }
+  };
   const attrMap = {};
   for (const key of keep) {
     const v = el.getAttribute(key) ?? el[key];
@@ -124,10 +160,18 @@ function probeElementAttrs(el, arg) {
       const targetRole = roleOf(el);
       const targetLevel = targetRole === "heading" ? levelOf(el) : null;
       const nameOf = (n) => {
+        const labelledBy = !!n.getAttribute("aria-labelledby");
+        const isField = FIELD_TAGS.indexOf((n.tagName || "").toLowerCase()) !== -1;
+        const lt = labelledBy || isField ? labelTextOf(n) : null;
+        if (lt && labelledBy) return lt;
         const al = n.getAttribute("aria-label");
         if (al) return al;
-        const txt = (n.textContent || "").replace(/\s+/g, " ").trim();
-        if (txt) return txt;
+        if (isField) {
+          if (lt) return lt;
+        } else {
+          const txt = (n.textContent || "").replace(/\s+/g, " ").trim();
+          if (txt) return txt;
+        }
         return n.getAttribute("title") || n.getAttribute("placeholder") || null;
       };
       const targetName = nameOf(el);
@@ -319,16 +363,7 @@ function probeElementAttrs(el, arg) {
     }
   }
   const hasLabel = !!(el.labels && el.labels.length > 0);
-  let labelText;
-  if (includeLabelText) {
-    labelText = null;
-    try {
-      const label = hasLabel ? el.labels[0] : null;
-      labelText = (label && label.textContent || "").replace(/\s+/g, " ").trim().slice(0, 120) || null;
-    } catch {
-      labelText = null;
-    }
-  }
+  const labelText = labelTextOf(el);
   return {
     tagName: el.tagName?.toLowerCase?.() ?? "unknown",
     attributes: attrMap,
@@ -340,7 +375,7 @@ function probeElementAttrs(el, arg) {
       y: Math.round(r.y + r.height / 2)
     },
     hasLabel,
-    ...includeLabelText ? { labelText } : {},
+    labelText,
     selectorCounts,
     ...includeStructural ? { rolePosition, ancestors } : {}
   };
@@ -493,6 +528,11 @@ function installPickerOverlay(arg) {
     placeLabel(r);
     foot.textContent = "click to pick \xB7 \u2191 parent \xB7 \u2193 child \xB7 Esc skip";
   };
+  const redescribe = () => {
+    labeled = null;
+    if (current()) refresh();
+  };
+  g.__piwiRedescribe = redescribe;
   const stop = (e) => {
     e.preventDefault();
     e.stopImmediatePropagation();
@@ -547,6 +587,7 @@ function installPickerOverlay(arg) {
     highlight.remove();
     label.remove();
     banner.remove();
+    if (g.__piwiRedescribe === redescribe) delete g.__piwiRedescribe;
   };
   const reportPicked = (el) => {
     removePickingListeners();
@@ -1093,8 +1134,9 @@ function isAutoGenerated(value) {
   }
   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 (/^(radix-|headlessui-|mui-|mantine-|chakra-|reka-|bits-|downshift-|react-aria|el-id-)/i.test(value)) return true;
   if (/^:r[0-9a-z]+:$/i.test(value) || /^«r[0-9a-z]+»$/i.test(value)) return true;
+  if (/(^|[-_:])v-\d+(-\d+)+$/.test(value) || /(^|[-_:])v-\d+(-\d+)+[-_:]/.test(value)) return true;
   return false;
 }
 var TEST_DATA_ATTRS = /* @__PURE__ */ new Set(["data-test", "data-test-id", "data-qa", "data-qa-id", "data-cy", "data-e2e"]);
@@ -1311,9 +1353,15 @@ function generateAlternatives(attrs) {
 }
 function approximateAccessibleName(attrs) {
   const a = attrs.attributes;
+  const labelText = attrs.labelText || null;
+  if (a["aria-labelledby"] && labelText) return labelText;
   const ariaLabel = a["aria-label"];
   if (ariaLabel) return ariaLabel;
-  if (attrs.textContent) return attrs.textContent;
+  if (["input", "select", "textarea"].includes(attrs.tagName)) {
+    if (labelText) return labelText;
+  } else if (attrs.textContent) {
+    return attrs.textContent;
+  }
   const title = a["title"];
   if (title) return title;
   const placeholder = a["placeholder"];
@@ -1743,6 +1791,8 @@ var ATTACHMENT_NAMES = {
   dialogs: "piwi-dialogs",
   network: "piwi-network",
   pageInventory: "piwi-page-inventory",
+  locatorPages: "piwi-locator-pages",
+  codeReach: "piwi-code-reach",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
   pageState: "piwi-page-state",
@@ -1869,6 +1919,99 @@ function inventoryPageKey(url) {
   }
 }
 
+// ../core/src/page-key.ts
+function normalizeRoute(url) {
+  try {
+    const parsed = new URL(url);
+    let pathname = parsed.pathname;
+    pathname = pathname.replace(/\/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+(?=\/|$)/g, "/:jwt");
+    pathname = pathname.replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?=\/|$)/gi, "/:uuid");
+    pathname = pathname.replace(/\/[0-9ABCDEFGHJKMNPQRSTVWXYZ]{26}(?=\/|$)/gi, "/:ulid");
+    pathname = pathname.replace(/\/[A-Za-z0-9_-]{40,}(?=\/|$)/g, "/:token");
+    pathname = pathname.replace(/\/[0-9a-f]{32,}(?=\/|$)/gi, "/:token");
+    pathname = pathname.replace(/\/\d+(?=\/|$)/g, "/:id");
+    let queryString = "";
+    if (parsed.search) {
+      const params = new URLSearchParams(parsed.search);
+      const redacted = new URLSearchParams();
+      for (const [key] of params) {
+        redacted.set(key, "<redacted>");
+      }
+      queryString = "?" + redacted.toString();
+    }
+    return `${pathname}${queryString}`;
+  } catch {
+    return url;
+  }
+}
+var PATH_ANCHOR_HOST = "piwi.invalid";
+function pageKey(url) {
+  const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(url);
+  if (hasScheme && !/^https?:\/\//i.test(url)) return null;
+  const absolute = /^https?:\/\//i.test(url) ? url : `http://${PATH_ANCHOR_HOST}${url.startsWith("/") ? "" : "/"}${url}`;
+  const normalized = normalizeRoute(absolute);
+  const q = normalized.indexOf("?");
+  return q < 0 ? normalized : normalized.slice(0, q);
+}
+function requestRouteKey(method, url) {
+  const route = normalizeRoute(url ?? "");
+  const q = route.indexOf("?");
+  return `${(method || "GET").toUpperCase()} ${q === -1 ? route : route.slice(0, q)}`;
+}
+
+// src/internal/capture/locator-pages.ts
+var MAX_LOCATOR_PAGE_ENTRIES = 1e3;
+var MAX_LOCATOR_CHARS = 1e3;
+var NON_INTERACTIONS = /* @__PURE__ */ new Set(["waitFor"]);
+var interactions = /* @__PURE__ */ new WeakMap();
+function noteNavigation(page) {
+  interactions.set(page, 0);
+}
+function isOnArrival(page) {
+  return (interactions.get(page) ?? 0) === 0;
+}
+function noteLocatorCall(page, method, assertion = false) {
+  const arrival = isOnArrival(page);
+  if (!assertion && !NON_INTERACTIONS.has(method)) interactions.set(page, (interactions.get(page) ?? 0) + 1);
+  return arrival;
+}
+function pageOf(url) {
+  const key = pageKey(url);
+  if (key === null) return null;
+  try {
+    const origin = new URL(url).origin;
+    return origin && origin !== "null" ? { origin, page: key } : null;
+  } catch {
+    return null;
+  }
+}
+var LocatorPageLog = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  /** Record one call. Silently skipped without a call site, off an http(s) page, or past the limits. */
+  record(call) {
+    if (!call.location || !call.locator || call.locator.length > MAX_LOCATOR_CHARS) return;
+    const where = pageOf(call.url);
+    if (!where) return;
+    const key = `${call.location}\0${call.locator}\0${where.origin}\0${where.page}`;
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.arrival ||= call.arrival;
+      return;
+    }
+    if (this.entries.size >= MAX_LOCATOR_PAGE_ENTRIES) return;
+    this.entries.set(key, { location: call.location, locator: call.locator, ...where, arrival: call.arrival });
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** The entries in the order the calls first happened. */
+  list() {
+    return [...this.entries.values()];
+  }
+};
+
 // src/internal/probe/mode.ts
 var fs2 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
@@ -1892,6 +2035,8 @@ var DEFAULTS = {
   // Off by default: the page inventory reads control and link names from every
   // visited page, so it stays opt-in until a project turns it on.
   capturePageInventory: false,
+  // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
+  captureCodeReach: false,
   captureServerTraces: true,
   sampleAriaOnPass: true,
   uploadManifest: true,
@@ -1928,6 +2073,8 @@ var PIWI_ENV_KEYS = {
   captureLocators: "PIWI_CAPTURE_LOCATORS",
   capturePageState: "PIWI_CAPTURE_PAGE_STATE",
   capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
+  captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
+  codeReachRoots: "PIWI_CODE_REACH_ROOTS",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
   sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
   uploadManifest: "PIWI_UPLOAD_MANIFEST",
@@ -1950,6 +2097,10 @@ var PIWI_PROBE_ENV = {
   results: "PIWI_PROBE_RESULTS",
   secret: "PIWI_PROBE_SECRET"
 };
+var PIWI_FLAKE_ENV = {
+  plan: "PIWI_FLAKE_PLAN",
+  results: "PIWI_FLAKE_RESULTS"
+};
 var ENV_FALLBACK_SPECS = [
   { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
   { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
@@ -1971,6 +2122,7 @@ var ENV_FALLBACK_SPECS = [
   { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
   { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
   { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
+  { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
   { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
   { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
   { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
@@ -1981,14 +2133,14 @@ var ENV_FALLBACK_SPECS = [
 ];
 
 // src/internal/probe/plan.ts
-function parseRouteKey(routeKey) {
-  const space = routeKey.indexOf(" ");
-  if (space < 0) return { method: "", pattern: routeKey };
-  return { method: routeKey.slice(0, space).toUpperCase(), pattern: routeKey.slice(space + 1) };
+function parseRouteKey(routeKey2) {
+  const space = routeKey2.indexOf(" ");
+  if (space < 0) return { method: "", pattern: routeKey2 };
+  return { method: routeKey2.slice(0, space).toUpperCase(), pattern: routeKey2.slice(space + 1) };
 }
 function patternToRegex(pattern) {
-  const path6 = pattern.split("?")[0] ?? pattern;
-  const escaped = path6.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  const path11 = pattern.split("?")[0] ?? pattern;
+  const escaped = path11.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
   return new RegExp(`^${escaped}$`);
 }
 function suitePathEqual(a, b) {
@@ -2008,16 +2160,16 @@ function matchProbeItem(plan, test) {
   }
   return null;
 }
-function requestMatchesRoute(method, url, routeKey) {
-  const { method: rm, pattern } = parseRouteKey(routeKey);
+function requestMatchesRoute(method, url, routeKey2) {
+  const { method: rm, pattern } = parseRouteKey(routeKey2);
   if (rm && rm !== method.toUpperCase()) return false;
-  let path6;
+  let path11;
   try {
-    path6 = new URL(url).pathname;
+    path11 = new URL(url).pathname;
   } catch {
-    path6 = url.split("?")[0] ?? url;
+    path11 = url.split("?")[0] ?? url;
   }
-  return patternToRegex(pattern).test(path6);
+  return patternToRegex(pattern).test(path11);
 }
 function createProbeState() {
   return { navigated: false, matches: 0 };
@@ -2025,10 +2177,10 @@ function createProbeState() {
 function markNavigated(state) {
   state.navigated = true;
 }
-function shouldMutate(state, item) {
+function shouldAct(state, match) {
   if (!state.navigated) return false;
   state.matches += 1;
-  return state.matches === Math.max(1, item.nth ?? 1);
+  return match === "all" || state.matches === Math.max(1, match);
 }
 
 // src/internal/probe/mode.ts
@@ -2039,10 +2191,10 @@ function isProbeMode() {
 function loadPlan() {
   if (planCache !== void 0) return planCache;
   planCache = null;
-  const path6 = process.env[PIWI_PROBE_ENV.plan];
-  if (path6) {
+  const path11 = process.env[PIWI_PROBE_ENV.plan];
+  if (path11) {
     try {
-      planCache = JSON.parse(fs2.readFileSync(path6, "utf8"));
+      planCache = JSON.parse(fs2.readFileSync(path11, "utf8"));
     } catch {
       planCache = null;
     }
@@ -2064,10 +2216,10 @@ function outcomeFromStatus(status, applied) {
   return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
 }
 function recordProbeOutcome(line) {
-  const path6 = process.env[PIWI_PROBE_ENV.results];
-  if (!path6) return;
+  const path11 = process.env[PIWI_PROBE_ENV.results];
+  if (!path11) return;
   try {
-    fs2.appendFileSync(path6, `${JSON.stringify(line)}
+    fs2.appendFileSync(path11, `${JSON.stringify(line)}
 `);
   } catch {
   }
@@ -2094,6 +2246,9 @@ function isFaultAllowed(level, fault) {
   return list.includes(fault);
 }
 var SLOW_FAULT_DELAY_MS = 5e3;
+function faultRouteAction(fault) {
+  return fault === "slow" ? { kind: "delay", ms: SLOW_FAULT_DELAY_MS } : null;
+}
 function dropOneField(body) {
   let parsed;
   try {
@@ -2194,11 +2349,46 @@ function originOf(url) {
     return null;
   }
 }
+var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, Math.max(0, ms)));
+async function performRouteAction(route, action, startedAt) {
+  switch (action.kind) {
+    case "abort":
+      await route.abort("connectionreset");
+      return;
+    case "status":
+      await route.fulfill({ status: action.status, body: "" });
+      return;
+    case "delay": {
+      const response = await route.fetch();
+      await sleep(startedAt + action.ms - Date.now());
+      await route.fulfill({ response });
+      return;
+    }
+  }
+}
+async function installRouteRules(page, rules) {
+  const state = rules.map(() => createProbeState());
+  page.on("framenavigated", (frame) => {
+    if (frame === page.mainFrame()) for (const s of state) markNavigated(s);
+  });
+  await page.route("**/*", async (route) => {
+    const startedAt = Date.now();
+    const request = route.request();
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      if (rule.done?.() || !rule.matches(request.method(), request.url())) continue;
+      if (!shouldAct(state[i], rule.match)) continue;
+      await rule.handle(route, startedAt);
+      return;
+    }
+    await route.fallback();
+  });
+  return { state };
+}
 async function installProbeInterception(page, item) {
   if (!isFaultAllowed(item.level ?? "client", item.fault)) {
     return { applied: () => false, appliedFault: () => null, serverError: () => false };
   }
-  const state = createProbeState();
   let applied = false;
   let appliedFault = null;
   let serverError = false;
@@ -2206,17 +2396,12 @@ async function installProbeInterception(page, item) {
   const probeSecret = process.env[PIWI_PROBE_ENV.secret];
   page.on("framenavigated", (frame) => {
     if (frame === page.mainFrame()) {
-      markNavigated(state);
       const origin = originOf(page.url());
       if (origin) appOrigin = origin;
     }
   });
-  await page.route("**/*", async (route) => {
+  const handle = async (route, startedAt) => {
     const request = route.request();
-    if (applied || !requestMatchesRoute(request.method(), request.url(), item.routeKey) || !shouldMutate(state, item)) {
-      await route.fallback();
-      return;
-    }
     if (item.level === "server") {
       if (!probeSecret || appOrigin !== null && originOf(request.url()) !== appOrigin) {
         await route.fallback();
@@ -2240,6 +2425,13 @@ async function installProbeInterception(page, item) {
       return;
     }
     try {
+      const action = faultRouteAction(item.fault);
+      if (action) {
+        applied = true;
+        appliedFault = item.fault;
+        await performRouteAction(route, action, startedAt);
+        return;
+      }
       const response = await route.fetch();
       const body = await response.text();
       const out = computeFault(item.fault, {
@@ -2249,53 +2441,26 @@ async function installProbeInterception(page, item) {
       });
       applied = out.changed;
       if (applied) appliedFault = item.fault;
-      if (out.delayMs > 0) await new Promise((resolve) => setTimeout(resolve, out.delayMs));
       const headers = fulfillHeaders(response.headers(), out.contentType);
       await route.fulfill({ status: out.status, body: out.body, headers });
     } catch {
       applied = false;
       await route.fallback();
     }
-  });
-  return { applied: () => applied, appliedFault: () => appliedFault, serverError: () => serverError };
-}
-
-// 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
   };
+  await installRouteRules(page, [
+    {
+      matches: (method, url) => requestMatchesRoute(method, url, item.routeKey),
+      match: Math.max(1, item.nth ?? 1),
+      handle,
+      done: () => applied
+    }
+  ]);
+  return { applied: () => applied, appliedFault: () => appliedFault, serverError: () => serverError };
 }
 
-// src/internal/capture/pick-on-failure.ts
+// src/internal/flake/mode.ts
+var fs3 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 
 // ../core/src/locator-chain.ts
@@ -2580,8 +2745,474 @@ function locatorCallValues(call, opts = {}) {
   return call.args.map(value).filter((v) => v !== void 0);
 }
 
+// ../core/src/error-parse.ts
+var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+var SELECTOR_FN_RE = /\b(?:locator|frameLocator|getByRole|getByTestId|getByText|getByLabel|getByPlaceholder|getByAltText|getByTitle)\(/;
+var CHAIN_LINK_METHODS = /* @__PURE__ */ new Set([
+  ...LOCATOR_BUILDER_METHODS,
+  "frameLocator",
+  "contentFrame",
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "describe"
+]);
+function extractMessageHead(text) {
+  let head = text;
+  const callLogIdx = head.indexOf("\nCall log:");
+  if (callLogIdx !== -1) head = head.slice(0, callLogIdx);
+  const stackIdx = head.search(/\n\s+at /);
+  if (stackIdx !== -1) head = head.slice(0, stackIdx);
+  const lines = head.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  return lines.slice(0, 5).join("\n");
+}
+function extractSelector(text) {
+  const match = SELECTOR_FN_RE.exec(text);
+  if (!match) return null;
+  const start = match.index;
+  let depth = 0;
+  for (let i = start; i < Math.min(text.length, start + 200); i++) {
+    const ch = text[i];
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    } else if (ch === "\n") {
+      break;
+    }
+  }
+  return text.slice(start, start + 80);
+}
+var LEAF_METHODS = new Set(LOCATOR_BUILDER_METHODS);
+function extractTopFrame(text) {
+  const frameRe = /^\s+at (?:.*? \()?([^()\s][^()]*?):(\d+):(\d+)\)?\s*$/gm;
+  let m;
+  while ((m = frameRe.exec(text)) !== null) {
+    const file = m[1].replace(/\\/g, "/");
+    if (file.includes("node_modules") || file.startsWith("node:")) continue;
+    return { file, line: Number(m[2]), column: Number(m[3]) };
+  }
+  return null;
+}
+function extractTopFrameFile(text) {
+  return extractTopFrame(text)?.file ?? null;
+}
+var SUBJECTS = "locator|page|frame|frameLocator|elementHandle|mouse|keyboard|touchscreen|browserContext|browser|apiRequestContext|request|response|route|download|dialog|fileChooser|expect|worker|jsHandle|clock|tracing|video";
+var CALL_RE = new RegExp(`\\b(${SUBJECTS})\\.(\\w+): `);
+
+// ../core/src/error-signature.ts
+var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var LONG_HEX_RE = /\b[0-9a-f]{8,}\b/gi;
+var SHORT_HEX_RE = /\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*[0-9])[0-9a-f]{6,7}\b/gi;
+var URL_RE = /\bhttps?:\/\/[^\s'"`)]+/gi;
+var EMAIL_RE = /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/gi;
+function classifyError(text) {
+  if (/strict mode violation/i.test(text)) return "strict-mode";
+  if (/\bexpect\(|\bexpect\.|Expected (?:string|substring|pattern|value)|\.toHave|\.toBe|\.toContain|\.toEqual/.test(text))
+    return "assertion";
+  if (/Target page, context or browser has been closed|Target closed|browser has been closed|Page crashed/i.test(text))
+    return "crash";
+  if (/net::ERR_|NS_ERROR_|Navigation failed/i.test(text)) return "navigation";
+  if (/Timeout \d+m?s exceeded|TimeoutError|Timed out \d+m?s/i.test(text)) return "timeout";
+  return "unknown";
+}
+function maskVolatile(text) {
+  return text.replace(/^(\s*(?:Received|Expected)[^:\n]*:).*$/gm, "$1 <VALUE>").replace(URL_RE, "<URL>").replace(EMAIL_RE, "<EMAIL>").replace(UUID_RE, "<UUID>").replace(LONG_HEX_RE, "<HASH>").replace(SHORT_HEX_RE, "<HASH>").replace(/([A-Za-z])?(\d+)/g, (whole, letter) => letter ? whole : "<N>");
+}
+function extractErrorSignature(rawError) {
+  const text = stripAnsi(rawError);
+  const errorType = classifyError(text);
+  const normalizedMessage = maskVolatile(extractMessageHead(text));
+  const selector = extractSelector(text);
+  const topFrameFile = extractTopFrameFile(text);
+  const signature = (normalizedMessage.split("\n")[0] || "").slice(0, 200) || "Unknown error";
+  return { errorType, signature, normalizedMessage, selector, topFrameFile };
+}
+
+// ../core/src/flake-plan.ts
+var FLAKE_PLAN_VERSION = 1;
+var FLAKE_CONDITION_KINDS = [
+  "delay",
+  "fail",
+  "cpu",
+  "network",
+  "alongside",
+  "after",
+  "project"
+];
+var COMMAND_CONDITION_KINDS = ["alongside", "after", "project"];
+function flakeErrorSignature(rawError) {
+  return extractErrorSignature(rawError).normalizedMessage;
+}
+var FlakePlanError = class extends Error {
+  constructor(message) {
+    super(`Invalid flake plan: ${message}`);
+    this.name = "FlakePlanError";
+  }
+};
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function str(obj, key, at) {
+  const value = obj[key];
+  if (typeof value !== "string" || !value.trim()) throw new FlakePlanError(`${at}.${key} must be a non-empty string`);
+  return value;
+}
+function num(obj, key, at, min, max = Number.MAX_SAFE_INTEGER) {
+  const value = obj[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    throw new FlakePlanError(`${at}.${key} must be a number from ${min} to ${max}`);
+  }
+  return value;
+}
+function stringList(value, at) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new FlakePlanError(`${at} must be a list of strings`);
+  }
+  return value;
+}
+var ROUTE_KEY_RE = /^[A-Z]+ \/\S*$/;
+function routeKey(obj, at) {
+  const route = str(obj, "route", at);
+  if (!ROUTE_KEY_RE.test(route)) {
+    throw new FlakePlanError(`${at}.route must be a method and a path, like "GET /api/cart/:id" (got "${route}")`);
+  }
+  return route;
+}
+function routeMatch(obj, at) {
+  const value = obj.match;
+  if (value === void 0 || value === "all") return "all";
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
+  throw new FlakePlanError(`${at}.match must be "all" or a whole number from 1`);
+}
+function testRef(value, at) {
+  if (!isObject(value)) throw new FlakePlanError(`${at} must be an object`);
+  return {
+    file: str(value, "file", at),
+    title: str(value, "title", at),
+    suite: stringList(value.suite, `${at}.suite`)
+  };
+}
+function parseCondition(value, at) {
+  if (!isObject(value)) throw new FlakePlanError(`${at} must be an object`);
+  const kind = value.kind;
+  switch (kind) {
+    case "delay":
+      return { kind, route: routeKey(value, at), ms: num(value, "ms", at, 0, 6e5), match: routeMatch(value, at) };
+    case "fail": {
+      const route = routeKey(value, at);
+      const match = routeMatch(value, at);
+      if (value.abort === true) {
+        if (value.status !== void 0) throw new FlakePlanError(`${at} sets both status and abort; choose one`);
+        return { kind, route, abort: true, match };
+      }
+      const status = num(value, "status", at, 100, 599);
+      if (!Number.isInteger(status)) throw new FlakePlanError(`${at}.status must be a whole number`);
+      return { kind, route, status, match };
+    }
+    case "cpu":
+      return { kind, rate: num(value, "rate", at, 1, 100) };
+    case "network":
+      return {
+        kind,
+        latencyMs: num(value, "latencyMs", at, 0, 6e4),
+        downKbps: num(value, "downKbps", at, 1),
+        upKbps: num(value, "upKbps", at, 1)
+      };
+    case "alongside":
+    case "after":
+      return { kind, test: testRef(value.test, `${at}.test`) };
+    case "project":
+      return { kind, name: str(value, "name", at) };
+    default:
+      throw new FlakePlanError(
+        `${at}.kind ${JSON.stringify(kind)} is not a condition this version knows (${FLAKE_CONDITION_KINDS.join(", ")})`
+      );
+  }
+}
+function parseFlakePlan(value) {
+  if (!isObject(value)) throw new FlakePlanError("the plan must be a JSON object");
+  if (value.version !== FLAKE_PLAN_VERSION) {
+    throw new FlakePlanError(`version must be ${FLAKE_PLAN_VERSION} (got ${JSON.stringify(value.version)})`);
+  }
+  const experimentId = str(value, "experimentId", "plan");
+  if (!isObject(value.test)) throw new FlakePlanError("plan.test must be an object");
+  const ref = testRef(value.test, "plan.test");
+  const project = value.test.project;
+  if (project !== void 0 && project !== null && (typeof project !== "string" || !project.trim())) {
+    throw new FlakePlanError("plan.test.project must be a non-empty string or null");
+  }
+  if (!isObject(value.arm)) throw new FlakePlanError("plan.arm must be an object");
+  const armId = str(value.arm, "id", "plan.arm");
+  const rawConditions = value.arm.conditions ?? [];
+  if (!Array.isArray(rawConditions)) throw new FlakePlanError("plan.arm.conditions must be a list");
+  const conditions = rawConditions.map((c, i) => parseCondition(c, `plan.arm.conditions[${i}]`));
+  return {
+    version: FLAKE_PLAN_VERSION,
+    experimentId,
+    test: { ...ref, project: typeof project === "string" ? project : null },
+    arm: { id: armId, conditions },
+    errorSignatures: stringList(value.errorSignatures, "plan.errorSignatures")
+  };
+}
+function parseFlakePlanText(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new FlakePlanError(`not valid JSON (${error instanceof Error ? error.message : String(error)})`);
+  }
+  return parseFlakePlan(json);
+}
+function suiteEqual(a, b) {
+  return !!b && a.length === b.length && a.every((title, i) => title === b[i]);
+}
+function flakeTestMatches(ref, test) {
+  if (!test.file || ref.file !== test.file || ref.title !== test.title) return false;
+  return test.suite === void 0 || ref.suite.length === 0 || suiteEqual(ref.suite, test.suite);
+}
+
+// src/internal/support/errors.ts
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/internal/flake/mode.ts
+function isFlakeMode() {
+  return !!process.env[PIWI_FLAKE_ENV.plan]?.trim();
+}
+function labModeConflict() {
+  if (!isProbeMode() || !isFlakeMode()) return null;
+  return `[Piwi Dashboard] ${PIWI_PROBE_ENV.flag} and ${PIWI_FLAKE_ENV.plan} are both set: a run is a probe run or a flake-lab run, not both. Unset one of them.`;
+}
+var planCache2 = null;
+function loadFlakePlan() {
+  const file = process.env[PIWI_FLAKE_ENV.plan]?.trim() ?? "";
+  if (planCache2 && planCache2.file === file) return planCache2.plan;
+  let text;
+  try {
+    text = fs3.readFileSync(file, "utf8");
+  } catch (error) {
+    throw new Error(`[Piwi Dashboard] Cannot read the flake plan ${file}: ${errorMessage(error)}`);
+  }
+  try {
+    const plan = parseFlakePlanText(text);
+    planCache2 = { file, plan };
+    return plan;
+  } catch (error) {
+    throw new Error(`[Piwi Dashboard] ${errorMessage(error)} (${file})`);
+  }
+}
+function relativeTestFile(file) {
+  return file ? path4.relative(process.cwd(), file).split(path4.sep).join("/") : null;
+}
+function flakeRoleForTest(plan, test) {
+  const running = {
+    file: relativeTestFile(test.file),
+    title: test.title,
+    suite: test.titlePath ? test.titlePath.slice(1, -1) : void 0
+  };
+  if (flakeTestMatches(plan.test, running) && (plan.test.project === null || plan.test.project === test.project)) {
+    return "target";
+  }
+  const companion = plan.arm.conditions.some(
+    (c) => (c.kind === "alongside" || c.kind === "after") && flakeTestMatches(c.test, running)
+  );
+  return companion ? "companion" : null;
+}
+function pageBrowserName(page) {
+  try {
+    return page.context().browser()?.browserType().name() ?? null;
+  } catch {
+    return null;
+  }
+}
+function cdpCommandFor(condition) {
+  if (condition.kind === "cpu") return { method: "Emulation.setCPUThrottlingRate", params: { rate: condition.rate } };
+  if (condition.kind === "network") {
+    return {
+      method: "Network.emulateNetworkConditions",
+      params: {
+        offline: false,
+        latency: condition.latencyMs,
+        // Kilobits per second to bytes per second.
+        downloadThroughput: condition.downKbps * 1e3 / 8,
+        uploadThroughput: condition.upKbps * 1e3 / 8
+      }
+    };
+  }
+  return null;
+}
+function conditionRouteAction(condition) {
+  if (condition.kind === "delay") return { kind: "delay", ms: condition.ms };
+  if (condition.kind === "fail")
+    return "abort" in condition ? { kind: "abort" } : { kind: "status", status: condition.status };
+  return null;
+}
+function unappliedReports(plan) {
+  return plan.arm.conditions.map((c) => {
+    if (COMMAND_CONDITION_KINDS.includes(c.kind)) return { kind: c.kind, outcome: "by-command" };
+    if (cdpCommandFor(c)) return { kind: c.kind, outcome: "skipped", note: "the attempt opened no page" };
+    return { kind: c.kind, outcome: "not-matched" };
+  });
+}
+async function installFlakeConditions(page, plan) {
+  const conditions = plan.arm.conditions;
+  const reports = unappliedReports(plan);
+  const rules = [];
+  conditions.forEach((condition, i) => {
+    const action = conditionRouteAction(condition);
+    if (!action || condition.kind !== "delay" && condition.kind !== "fail") return;
+    const route = condition.route;
+    rules.push({
+      matches: (method, url) => requestRouteKey(method, url) === route,
+      match: condition.match,
+      handle: async (r, startedAt) => {
+        reports[i] = { kind: condition.kind, outcome: "applied" };
+        try {
+          await performRouteAction(r, action, startedAt);
+        } catch {
+          await r.fallback().catch(() => {
+          });
+        }
+      }
+    });
+  });
+  await installRouteRules(page, rules);
+  const cdp = conditions.map((c, i) => ({ i, command: cdpCommandFor(c) })).filter((c) => c.command);
+  if (cdp.length > 0) {
+    const browserName = pageBrowserName(page);
+    if (browserName !== null && browserName !== "chromium") {
+      for (const { i } of cdp) {
+        reports[i] = {
+          kind: conditions[i].kind,
+          outcome: "skipped",
+          note: `needs Chromium; this attempt ran in ${browserName}`
+        };
+      }
+    } else {
+      try {
+        const session = await page.context().newCDPSession(page);
+        for (const { i, command } of cdp) {
+          try {
+            if (command.method.startsWith("Network.")) await session.send("Network.enable");
+            await session.send(command.method, command.params);
+            reports[i] = { kind: conditions[i].kind, outcome: "applied" };
+          } catch (error) {
+            reports[i] = { kind: conditions[i].kind, outcome: "skipped", note: errorMessage(error) };
+          }
+        }
+      } catch (error) {
+        for (const { i } of cdp) {
+          reports[i] = {
+            kind: conditions[i].kind,
+            outcome: "skipped",
+            note: `no DevTools session: ${errorMessage(error)}`
+          };
+        }
+      }
+    }
+  }
+  return { reports: () => reports.map((r) => ({ ...r })) };
+}
+var FAILED_STATUSES = /* @__PURE__ */ new Set(["failed", "timedOut", "interrupted"]);
+function flakeResultLine(plan, attempt) {
+  const failed = FAILED_STATUSES.has(attempt.status);
+  const errorSignature = failed && attempt.errorText ? flakeErrorSignature(attempt.errorText) : null;
+  return {
+    version: FLAKE_PLAN_VERSION,
+    experimentId: plan.experimentId,
+    armId: plan.arm.id,
+    role: attempt.role,
+    file: relativeTestFile(attempt.file),
+    title: attempt.title,
+    project: attempt.project,
+    browserName: attempt.browserName,
+    status: attempt.status,
+    errorSignature,
+    matchesHistory: errorSignature !== null && plan.errorSignatures.includes(errorSignature),
+    startedAt: attempt.startedAt,
+    duration: attempt.duration,
+    workerIndex: attempt.workerIndex,
+    parallelIndex: attempt.parallelIndex,
+    repeatEachIndex: attempt.repeatEachIndex,
+    retry: attempt.retry,
+    conditions: attempt.role === "target" ? attempt.conditions : []
+  };
+}
+function recordFlakeResult(line) {
+  const file = process.env[PIWI_FLAKE_ENV.results]?.trim();
+  if (!file) return;
+  try {
+    fs3.appendFileSync(file, `${JSON.stringify(line)}
+`);
+  } catch {
+  }
+}
+
+// ../core/src/error-text.ts
+function joinErrorMessages(errors) {
+  if (!errors || errors.length === 0) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const err of errors) {
+    const msg = err.message ?? "";
+    if (!msg) continue;
+    const dedupeKey = msg.trim().slice(0, 200);
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    parts.push(msg);
+  }
+  return parts.join("\n---\n") || null;
+}
+
+// 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 ANSI_RE = /\[[0-9;]*m/g;
+var path5 = __toESM(require("path"));
+var ANSI_RE2 = /\[[0-9;]*m/g;
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
   return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
@@ -2591,13 +3222,13 @@ function deriveFailedLocator(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, "");
+${err.stack ?? ""}`.replace(ANSI_RE2, "");
     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 ? `${path4.relative(process.cwd(), loc.file).split(path4.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path5.relative(process.cwd(), loc.file).split(path5.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed.method, args: parsed.args, location };
   }
   return null;
@@ -2746,9 +3377,9 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/support/aria-sampling.ts
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 
 // src/internal/support/instance-id.ts
 var crypto = __toESM(require("crypto"));
@@ -2762,14 +3393,14 @@ function ariaSampleIdentity(filePath, title) {
   return `${filePath}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
-  return path5.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+  return path6.join(os3.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
 }
 var cachedSets = /* @__PURE__ */ new Map();
 function loadAriaSampleSet(projectName) {
   if (cachedSets.has(projectName)) return cachedSets.get(projectName);
   let set = null;
   try {
-    const raw = fs3.readFileSync(getAriaSampleFilePath(projectName), "utf8");
+    const raw = fs4.readFileSync(getAriaSampleFilePath(projectName), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.projectName === projectName && Array.isArray(parsed.identities)) {
       set = new Set(parsed.identities.filter((x) => typeof x === "string"));
@@ -2780,15 +3411,525 @@ function loadAriaSampleSet(projectName) {
   cachedSets.set(projectName, set);
   return set;
 }
-function relativeTestFile(file) {
-  return path5.relative(process.cwd(), file).split(path5.sep).join("/");
+function relativeTestFile2(file) {
+  return path6.relative(process.cwd(), file).split(path6.sep).join("/");
 }
 function isDueForAriaSample(testInfo) {
   const projectName = process.env.PIWI_PROJECT_NAME;
   if (!projectName) return false;
   const set = loadAriaSampleSet(projectName);
   if (!set || set.size === 0) return false;
-  return set.has(ariaSampleIdentity(relativeTestFile(testInfo.file), testInfo.title));
+  return set.has(ariaSampleIdentity(relativeTestFile2(testInfo.file), testInfo.title));
+}
+
+// src/internal/capture/quiet-capture.ts
+var import_node_module = require("module");
+var path8 = __toESM(require("path"));
+
+// src/internal/support/reporter-version.ts
+var fs5 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var CANDIDATE_OFFSETS = ["..", "../../.."];
+function findOwnPackageJson(fromDir) {
+  for (const offset of CANDIDATE_OFFSETS) {
+    try {
+      const pkgPath = path7.resolve(fromDir, offset, "package.json");
+      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+      const { name, version } = pkg;
+      if (name === "@piwitests/reporter" && typeof version === "string")
+        return { version, root: path7.dirname(pkgPath) };
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/internal/capture/quiet-capture.ts
+var BOXED_PREFIX_EXPORTS = [
+  [
+    "playwright-core/lib/coreBundle",
+    (mod) => mod?.utils?.setBoxedStackPrefixes
+  ],
+  ["playwright-core/lib/utils", (mod) => mod?.setBoxedStackPrefixes]
+];
+var boxing;
+function resolveBoxing() {
+  try {
+    const root = findOwnPackageJson(__dirname)?.root;
+    if (!root) return null;
+    const testPackageJson = (0, import_node_module.createRequire)(__filename).resolve("@playwright/test/package.json");
+    const playwrightPackageJson = (0, import_node_module.createRequire)(testPackageJson).resolve("playwright/package.json");
+    const requireFromPlaywright = (0, import_node_module.createRequire)(playwrightPackageJson);
+    for (const [moduleId, pick] of BOXED_PREFIX_EXPORTS) {
+      let set;
+      try {
+        set = pick(requireFromPlaywright(moduleId));
+      } catch {
+        continue;
+      }
+      if (typeof set !== "function") continue;
+      return {
+        set,
+        prefixes: [path8.dirname(playwrightPackageJson), path8.join(root, "dist") + path8.sep]
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function boxCaptureFrames(extraPrefixes = []) {
+  const first = boxing === void 0;
+  if (first) boxing = resolveBoxing();
+  if (!boxing) return;
+  const added = extraPrefixes.filter((prefix) => !boxing.prefixes.includes(prefix));
+  if (!first && added.length === 0) return;
+  boxing.prefixes.push(...added);
+  try {
+    boxing.set([...boxing.prefixes]);
+  } catch {
+  }
+}
+function internalCall(owner, run) {
+  const wrap = owner?._wrapApiCall;
+  if (typeof wrap !== "function") return run();
+  return wrap.call(owner, run, { internal: true, title: "Piwi capture" });
+}
+
+// src/internal/capture/code-reach.ts
+var crypto2 = __toESM(require("crypto"));
+var fs6 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+
+// ../core/src/source-map.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_VALUE = new Int8Array(128).fill(-1);
+for (let i = 0; i < BASE64.length; i++) BASE64_VALUE[BASE64.charCodeAt(i)] = i;
+function decodeMappings(mappings, sourceBase) {
+  const lines = [];
+  let current = { columns: [], sources: [] };
+  let column = 0;
+  let source = 0;
+  const fields = [];
+  let value = 0;
+  let shift = 0;
+  const flush = () => {
+    if (fields.length === 0) return;
+    column += fields[0];
+    if (fields.length >= 4) {
+      source += fields[1];
+      current.columns.push(column);
+      current.sources.push(sourceBase + source);
+    } else {
+      current.columns.push(column);
+      current.sources.push(-1);
+    }
+    fields.length = 0;
+  };
+  for (let i = 0; i <= mappings.length; i++) {
+    const ch = i < mappings.length ? mappings.charCodeAt(i) : 59;
+    if (ch === 59 || ch === 44) {
+      flush();
+      if (ch === 59) {
+        lines.push(current);
+        current = { columns: [], sources: [] };
+        column = 0;
+      }
+      continue;
+    }
+    const digit = ch < 128 ? BASE64_VALUE[ch] : -1;
+    if (digit < 0) continue;
+    value += (digit & 31) << shift;
+    if (digit & 32) {
+      shift += 5;
+      continue;
+    }
+    fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
+    value = 0;
+    shift = 0;
+  }
+  for (const line of lines) {
+    if (line.columns.every((c, i) => i === 0 || c >= line.columns[i - 1])) continue;
+    const order = line.columns.map((_, i) => i).sort((a, b) => line.columns[a] - line.columns[b]);
+    line.columns = order.map((i) => line.columns[i]);
+    line.sources = order.map((i) => line.sources[i]);
+  }
+  return lines;
+}
+function joinRoot(root, source) {
+  if (!root || /^[a-z][\w+.-]*:/i.test(source) || source.startsWith("/")) return source;
+  return root.endsWith("/") ? root + source : `${root}/${source}`;
+}
+function decodeSourceMap(raw) {
+  const sources = [];
+  const lines = [];
+  const add = (map, lineOffset, columnOffset) => {
+    if (map.sections) {
+      for (const section of map.sections) {
+        if (!add(section.map, section.offset.line, section.offset.column)) return false;
+      }
+      return true;
+    }
+    if (typeof map.mappings !== "string" || !Array.isArray(map.sources)) return false;
+    const base = sources.length;
+    for (const s of map.sources) sources.push(joinRoot(map.sourceRoot, s ?? ""));
+    decodeMappings(map.mappings, base).forEach((segments, i) => {
+      const at = lineOffset + i;
+      const shifted = i === 0 && columnOffset ? segments.columns.map((c) => c + columnOffset) : segments.columns;
+      const existing = lines[at];
+      if (!existing) lines[at] = { columns: shifted, sources: segments.sources };
+      else {
+        existing.columns.push(...shifted);
+        existing.sources.push(...segments.sources);
+      }
+    });
+    return true;
+  };
+  if (raw.version !== void 0 && raw.version !== 3) return null;
+  if (!add(raw, 0, 0)) return null;
+  return {
+    sources,
+    sourceAt(line, column) {
+      const segments = lines[line];
+      if (!segments || segments.columns.length === 0) return null;
+      let lo = 0;
+      let hi = segments.columns.length - 1;
+      if (segments.columns[0] > column) return null;
+      while (lo < hi) {
+        const mid = lo + hi + 1 >> 1;
+        if (segments.columns[mid] <= column) lo = mid;
+        else hi = mid - 1;
+      }
+      const source = segments.sources[lo];
+      return source < 0 ? null : source;
+    },
+    mapsBetween(source, start, end) {
+      for (let line = start.line; line <= end.line && line < lines.length; line++) {
+        const segments = lines[line];
+        if (!segments) continue;
+        let i = 0;
+        if (line === start.line) {
+          let hi = segments.columns.length;
+          while (i < hi) {
+            const mid = i + hi >> 1;
+            if (segments.columns[mid] < start.column) i = mid + 1;
+            else hi = mid;
+          }
+        }
+        for (; i < segments.columns.length; i++) {
+          if (line === end.line && segments.columns[i] >= end.column) return false;
+          if (segments.sources[i] === source) return true;
+        }
+      }
+      return false;
+    }
+  };
+}
+function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  return starts;
+}
+function offsetToPosition(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo, column: offset - starts[lo] };
+}
+function sourceMappingUrl(script) {
+  const tail = script.slice(-4096);
+  const matches = [...tail.matchAll(/(?:\/\/|\/\*)[#@]\s*sourceMappingURL=([^\s*'"]+)/g)];
+  return matches.length ? matches[matches.length - 1][1] : null;
+}
+function decodeDataUrl(url) {
+  const m = /^data:([^,]*?)(;base64)?,(.*)$/s.exec(url);
+  if (!m) return null;
+  try {
+    if (!m[2]) return decodeURIComponent(m[3]);
+    const binary = globalThis.atob(m[3]);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function normalizeSourcePath(source) {
+  let s = source.replace(/[?#].*$/, "");
+  s = s.replace(/^webpack:\/\/[^/]*\//, "").replace(/^webpack:\/\//, "");
+  s = s.replace(/^(?:vite|rollup|turbopack|ng):\/*/, "");
+  s = s.replace(/^\[project\]\//, "");
+  s = s.replace(/^file:\/\//, "");
+  s = s.replace(/^\/@fs\//, "/");
+  s = s.replace(/^\/@id\//, "");
+  try {
+    s = decodeURIComponent(s);
+  } catch {
+  }
+  s = s.replace(/\\/g, "/");
+  if (/^\/[A-Za-z]:\//.test(s)) s = s.slice(1);
+  s = s.replace(/(^|\/)\.\//g, "$1");
+  return s;
+}
+
+// ../core/src/code-reach.ts
+var MAX_CODE_REACH_FILES = 2e3;
+function executedFunctionRanges(entry) {
+  const length = entry.source?.length ?? Number.POSITIVE_INFINITY;
+  const out = [];
+  entry.functions.forEach((fn, i) => {
+    const whole = fn.ranges[0];
+    if (!whole || whole.count <= 0) return;
+    const topLevel = whole.startOffset === 0 && (whole.endOffset >= length || i === 0 && fn.functionName === "");
+    if (topLevel) return;
+    out.push({ start: whole.startOffset, end: whole.endOffset });
+  });
+  return out;
+}
+function executedFunctionOffsets(entry) {
+  return executedFunctionRanges(entry).map((range) => range.start);
+}
+function scriptRan(entry) {
+  return executedFunctionOffsets(entry).length > 0;
+}
+function reachedSources(entry, map) {
+  const ranges = executedFunctionRanges(entry);
+  const reached = /* @__PURE__ */ new Set();
+  if (!ranges.length || entry.source === void 0) return reached;
+  const starts = lineStarts(entry.source);
+  for (const range of ranges) {
+    const start = offsetToPosition(starts, range.start);
+    const source = map.sourceAt(start.line, start.column);
+    if (source === null || reached.has(source)) continue;
+    if (map.mapsBetween(source, start, offsetToPosition(starts, range.end))) reached.add(source);
+  }
+  return reached;
+}
+function finalizeCodeReach(files) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of files) {
+    const file = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!file || file.startsWith("../") || file.startsWith("/") || /^[A-Za-z]:\//.test(file)) continue;
+    if (/(^|\/)node_modules\//.test(file)) continue;
+    out.add(file);
+  }
+  return [...out].sort().slice(0, MAX_CODE_REACH_FILES);
+}
+
+// src/internal/capture/code-reach.ts
+var MAX_MAP_BYTES = 20 * 1024 * 1024;
+var MAP_TIMEOUT_MS = 5e3;
+var SOURCE_EXTENSIONS = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|marko|html?)$/i;
+var REPLAYED_SCRIPT = /^(?:about|rsc):/i;
+var BUILD_DIRS = /(?:^|\/)(?:dist|build|out|\.output|\.next|\.nuxt|\.svelte-kit|public|static|wwwroot)\//;
+var MAX_CACHED_SCRIPTS = 500;
+var LatestByUrl = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  get(url, version) {
+    const entry = this.entries.get(url);
+    if (!entry || entry.version !== version) return void 0;
+    this.entries.delete(url);
+    this.entries.set(url, entry);
+    return entry.value;
+  }
+  set(url, version, value) {
+    this.entries.delete(url);
+    this.entries.set(url, { version, value });
+    if (this.entries.size > MAX_CACHED_SCRIPTS) this.entries.delete(this.entries.keys().next().value);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var scriptCache = new LatestByUrl();
+var mapCache = new LatestByUrl();
+var cachedRepoRoot = null;
+function repositoryRoot(from) {
+  if (cachedRepoRoot?.from === from) return cachedRepoRoot.root;
+  let root = from;
+  try {
+    root = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+      cwd: from,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+  }
+  cachedRepoRoot = { from, root: path9.resolve(root) };
+  return cachedRepoRoot.root;
+}
+function codeReachRoots(configDir, configured) {
+  const repoRoot = repositoryRoot(configDir);
+  const roots = configured?.length ? configured.map((r) => path9.resolve(configDir, r)) : [configDir];
+  return { roots: [.../* @__PURE__ */ new Set([...roots, repoRoot])], repoRoot };
+}
+function isFile(file) {
+  try {
+    return fs6.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveSourcePath(source, roots) {
+  const normalized = normalizeSourcePath(source);
+  if (!normalized || /(?:^|\/)node_modules\//.test(normalized)) return null;
+  if (path9.isAbsolute(normalized) && isFile(normalized)) return path9.resolve(normalized);
+  const relative7 = normalized.replace(/^\/+/, "");
+  for (const root of roots) {
+    const candidate = path9.resolve(root, relative7);
+    if (isFile(candidate)) return candidate;
+  }
+  return null;
+}
+function viteBases(entries) {
+  const bases = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const match = /^(https?:\/\/[^/]+)(\/.*?)@vite\/client$/.exec(entry.url.replace(/[?#].*$/, ""));
+    if (match && match[2] !== "/") bases.set(match[1], match[2]);
+  }
+  return bases;
+}
+function fileForUrl(url, roots, bases) {
+  let pathname;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" && parsed.protocol !== "file:") return null;
+    pathname = parsed.pathname;
+    const base = bases.get(parsed.origin);
+    if (base && pathname.startsWith(base)) pathname = pathname.slice(base.length - 1);
+  } catch {
+    return null;
+  }
+  if (!SOURCE_EXTENSIONS.test(pathname) || pathname.startsWith("/@vite/") || pathname.includes("/node_modules/")) {
+    return null;
+  }
+  const file = resolveSourcePath(pathname, roots);
+  if (!file || BUILD_DIRS.test(file.replace(/\\/g, "/"))) return null;
+  return file;
+}
+function relativeToRepo(file, repoRoot) {
+  return path9.relative(repoRoot, file).split(path9.sep).join("/");
+}
+function scriptHash(entry) {
+  return crypto2.createHash("sha1").update(entry.source ?? "").digest("hex");
+}
+async function loadMap(entry, fetchMap) {
+  const ref = entry.source ? sourceMappingUrl(entry.source) : null;
+  if (!ref) return null;
+  if (ref.startsWith("data:")) {
+    const text = decodeDataUrl(ref);
+    return text ? parseMap(text) : null;
+  }
+  let absolute;
+  try {
+    absolute = new URL(ref, entry.url).href;
+  } catch {
+    return null;
+  }
+  const version = scriptHash(entry);
+  let pending = mapCache.get(absolute, version);
+  if (!pending) {
+    pending = fetchMap(absolute).then((text) => text ? parseMap(text) : null);
+    mapCache.set(absolute, version, pending);
+  }
+  return pending;
+}
+function parseMap(text) {
+  try {
+    return decodeSourceMap(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+async function resolveScript(entry, roots, bases, fetchMap) {
+  const version = scriptHash(entry);
+  const cached = scriptCache.get(entry.url, version);
+  if (cached) return cached;
+  let resolution;
+  const file = fileForUrl(entry.url, roots.roots, bases);
+  if (file) resolution = { kind: "file", file, lookup: await loadMap(entry, fetchMap) };
+  else {
+    const lookup = await loadMap(entry, fetchMap);
+    resolution = lookup ? { kind: "map", lookup, files: [] } : { kind: "none" };
+  }
+  scriptCache.set(entry.url, version, resolution);
+  return resolution;
+}
+async function resolveCodeReach(entries, roots, fetchMap) {
+  const files = /* @__PURE__ */ new Set();
+  const bases = viteBases(entries);
+  for (const entry of entries) {
+    if (!entry.url || !entry.functions?.length || REPLAYED_SCRIPT.test(entry.url)) continue;
+    const resolution = await resolveScript(entry, roots, bases, fetchMap);
+    if (resolution.kind === "file") {
+      const ran = resolution.lookup ? reachedSources(entry, resolution.lookup).size > 0 : scriptRan(entry);
+      if (resolution.file && ran) files.add(relativeToRepo(resolution.file, roots.repoRoot));
+    } else if (resolution.kind === "map") {
+      for (const index of reachedSources(entry, resolution.lookup)) {
+        if (resolution.files[index] === void 0) {
+          const source = resolution.lookup.sources[index] ?? "";
+          let absolute = resolveSourcePath(source, roots.roots);
+          if (!absolute && !/^[a-z][\w+.-]*:/i.test(source)) {
+            try {
+              absolute = fileForUrl(new URL(source, entry.url).href, roots.roots, bases);
+            } catch {
+              absolute = null;
+            }
+          }
+          resolution.files[index] = absolute;
+        }
+        const file = resolution.files[index];
+        if (file) files.add(relativeToRepo(file, roots.repoRoot));
+      }
+    }
+  }
+  return finalizeCodeReach(files);
+}
+function pageMapFetcher(page) {
+  return async (url) => {
+    try {
+      const response = await internalCall(page, () => page.request.get(url, { timeout: MAP_TIMEOUT_MS }));
+      if (!response.ok()) return null;
+      const length = Number(response.headers()["content-length"] ?? 0);
+      if (length > MAX_MAP_BYTES) return null;
+      const body = await response.body();
+      return body.length > MAX_MAP_BYTES ? null : body.toString("utf-8");
+    } catch {
+      return null;
+    }
+  };
+}
+function isChromiumPage(page) {
+  try {
+    return page.context().browser()?.browserType().name() === "chromium";
+  } catch {
+    return false;
+  }
+}
+async function startCodeReach(page) {
+  if (!isChromiumPage(page) || !page.coverage) return false;
+  try {
+    await internalCall(
+      page,
+      () => page.coverage.startJSCoverage({ resetOnNavigation: false, reportAnonymousScripts: false })
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopCodeReach(page) {
+  try {
+    return await internalCall(page, () => page.coverage.stopJSCoverage());
+  } catch {
+    return null;
+  }
 }
 
 // src/internal/capture/capture-fixtures.ts
@@ -2840,10 +3981,53 @@ function createSink() {
     pageInventories: [],
     probeItem: null,
     probeInterception: null,
+    flake: null,
     pickOffered: false,
-    userPick: null
+    userPick: null,
+    locatorPages: new LocatorPageLog(),
+    codeReach: null
   };
 }
+function maybeStartCodeReach(page) {
+  const sink = currentSink;
+  if (!sink || process.env.PIWI_CAPTURE_CODE_REACH !== "true") return Promise.resolve(false);
+  if (sink.codeReach) return sink.codeReach.page === page ? sink.codeReach.started : Promise.resolve(false);
+  const started = startCodeReach(page);
+  sink.codeReach = { page, started, stopped: false, files: null };
+  return started;
+}
+function configuredCodeReachRoots() {
+  const raw = process.env.PIWI_CODE_REACH_ROOTS?.trim();
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed.filter((r) => typeof r === "string" && r !== "");
+  } catch {
+  }
+  return raw.split(path10.delimiter).filter(Boolean);
+}
+async function stopSinkCodeReach(sink, closing) {
+  const session = sink.codeReach;
+  if (!session || session.stopped) return;
+  if (closing && closing.page !== session.page && (!closing.context || pageContext(session.page) !== closing.context)) {
+    return;
+  }
+  session.stopped = true;
+  try {
+    if (!await session.started || isPageClosed(session.page)) return;
+    const entries = await stopCodeReach(session.page);
+    if (!entries) return;
+    const info = sink.testInfo;
+    const configFile = info?.config.configFile;
+    const configDir = configFile ? path10.dirname(configFile) : info?.config.rootDir ?? process.cwd();
+    session.files = await resolveCodeReach(
+      entries,
+      codeReachRoots(configDir, configuredCodeReachRoots()),
+      pageMapFetcher(session.page)
+    );
+  } catch {
+  }
+}
 var currentSink = null;
 var PENDING_PROBES = /* @__PURE__ */ new Set();
 async function drainPendingProbes(capMs) {
@@ -2851,8 +4035,8 @@ async function drainPendingProbes(capMs) {
   let cap;
   await Promise.race([
     Promise.allSettled(PENDING_PROBES),
-    new Promise((resolve) => {
-      cap = setTimeout(resolve, capMs);
+    new Promise((resolve3) => {
+      cap = setTimeout(resolve3, capMs);
     })
   ]);
   clearTimeout(cap);
@@ -2892,10 +4076,10 @@ async function readWebVitals(page) {
         const key = entry.name.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
         paint[key] = Math.round(entry.startTime);
       }
-      const readBuffered = (type, extra) => new Promise((resolve) => {
+      const readBuffered = (type, extra) => new Promise((resolve3) => {
         try {
           const PO = globalThis.PerformanceObserver;
-          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve(null);
+          if (!PO || !(PO.supportedEntryTypes || []).includes(type)) return resolve3(null);
           const out = [];
           const po = new PO((list) => out.push(...list.getEntries()));
           po.observe({ type, buffered: true, ...extra });
@@ -2905,10 +4089,10 @@ async function readWebVitals(page) {
               po.disconnect();
             } catch {
             }
-            resolve(out);
+            resolve3(out);
           }, 0);
         } catch {
-          resolve(null);
+          resolve3(null);
         }
       });
       const [lcpRaw, shiftRaw, eventRaw, firstInputRaw] = await Promise.all([
@@ -3021,12 +4205,12 @@ var PAGE_INVENTORY_IN_PAGE_CAP = 2e3;
 var PAGE_INVENTORY_EVAL_TIMEOUT_MS = 2e3;
 var MAX_PAGE_INVENTORY_WINDOWS = 64;
 function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve(value);
+        resolve3(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -3060,7 +4244,7 @@ async function recordPageWindow(sink, page) {
   if (sink.pageInventories.length >= MAX_PAGE_INVENTORY_WINDOWS) return;
   if (key && !inventoriedPageKeys.has(key)) {
     inventoriedPageKeys.add(key);
-    const content = await readPageInventory(page);
+    const content = await internalCall(page, () => readPageInventory(page));
     if (sink.pageInventories.length >= MAX_PAGE_INVENTORY_WINDOWS) return;
     sink.pageInventories.push({
       url: content?.url ?? url,
@@ -3077,6 +4261,9 @@ async function stashPageState(sink, closing) {
   if (!page || isPageClosed(page)) return;
   const belongsToClosing = closing.page === page || closing.context !== void 0 && pageContext(page) === closing.context;
   if (!belongsToClosing) return;
+  await internalCall(page, () => readPageBeforeClose(sink, page));
+}
+async function readPageBeforeClose(sink, page) {
   const vitals = await readWebVitals(page);
   if (vitals) sink.stashedWebVitals = vitals;
   if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
@@ -3118,7 +4305,10 @@ async function maybeOpenPicker(sink, closing) {
     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 });
+  const pick = await internalCall(
+    page,
+    () => runLocatorPicker(page, testInfo, failed, { fn: probeElementAttrs, arg: CAPTURED_ATTRS_ARG })
+  );
   if (!pick) return;
   sink.userPick = pick;
   applyPickToSnapshots(sink.capturedLocators, pick);
@@ -3137,12 +4327,8 @@ var CAPTURED_ATTRS_ARG = {
   // special-cased logic in the probe, so add them explicitly).
   roleSources: [.../* @__PURE__ */ new Set(["[role]", "input", "select", ...Object.keys(TAG_TO_ROLE)])].join(","),
   // The reporter always wants ancestor-anchored alternatives (the picker's
-  // anchors step and generateAnchoredAlternatives both need them). `labelText`
-  // is what names a form field, and the probe reads it from `el.labels` in the
-  // same pass — so asking for it here is free and settles the accessible name
-  // of a labeled field without a second round trip (`exactAccessibleName`).
-  includeStructural: true,
-  includeLabelText: true
+  // anchors step and generateAnchoredAlternatives both need them).
+  includeStructural: true
 };
 var PROBE_GLOBAL = "__piwiProbeElement";
 var PROBE_INIT_SCRIPT = `(() => {
@@ -3153,15 +4339,18 @@ var PROBE_INIT_SCRIPT = `(() => {
 var PROBE_UNSEEDED_PAGES = /* @__PURE__ */ new WeakSet();
 function probeElement(page, target) {
   const shipSource = () => target.evaluate(probeElementAttrs, CAPTURED_ATTRS_ARG);
-  if (!page || PROBE_UNSEEDED_PAGES.has(page)) return shipSource();
-  return target.evaluate((el, name) => {
-    const seeded = globalThis[name];
-    return typeof seeded === "function" ? seeded(el) : null;
-  }, PROBE_GLOBAL).then((attrs) => {
-    if (attrs) return attrs;
-    PROBE_UNSEEDED_PAGES.add(page);
-    return shipSource();
-  });
+  if (!page || PROBE_UNSEEDED_PAGES.has(page)) return internalCall(page, shipSource);
+  return internalCall(
+    page,
+    () => target.evaluate((el, name) => {
+      const seeded = globalThis[name];
+      return typeof seeded === "function" ? seeded(el) : null;
+    }, PROBE_GLOBAL).then((attrs) => {
+      if (attrs) return attrs;
+      PROBE_UNSEEDED_PAGES.add(page);
+      return shipSource();
+    })
+  );
 }
 async function ariaSnapshotBestEffort(target, timeout) {
   if (typeof target.ariaSnapshot !== "function") return null;
@@ -3212,7 +4401,7 @@ function startElementCapture(sink, page, target, seq, callerLocation, used) {
       const role = resolveAriaRole({ ...attrs, accessibleName: null });
       const isFormField = FORM_FIELD_TAGS.has(attrs.tagName);
       const exactName = exactAccessibleName(attrs, role);
-      const aria = exactName === null && (role || isFormField) ? await ariaSnapshotBestEffort(target, 500) : null;
+      const aria = exactName === null && (role || isFormField) ? await internalCall(page, () => ariaSnapshotBestEffort(target, 500)) : null;
       const accessibleName = exactName ?? (extractAccessibleName(aria) || approximateAccessibleName({ ...attrs, accessibleName: null }));
       sink.capturedLocators[seq] = {
         location: callerLocation,
@@ -3240,15 +4429,23 @@ function startElementCapture(sink, page, target, seq, callerLocation, used) {
   })();
   sink.capturePromises.push(resolveAttrs);
 }
+function callMethod(target, prop, args) {
+  return target[prop](...args);
+}
+function recordLocatorPage(sink, page, locator, location, arrival) {
+  try {
+    sink.locatorPages.record({ location, locator: String(locator), url: page.url(), arrival });
+  } catch {
+  }
+}
 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);
+          const next = callMethod(target, prop, args);
           if (LOCATOR_CREATING_CHAINS.has(prop)) {
             return wrapLocator(page, next, String(prop), args);
           }
@@ -3260,11 +4457,12 @@ function wrapLocator(page, locator, originMethod, originArgs) {
           const sink = currentSink;
           const expression = typeof callArgs[0] === "string" ? callArgs[0] : "";
           const isNot = Boolean(callArgs[1]?.isNot);
+          const callerLocation = sink ? captureCallerLocation() : null;
+          if (sink) recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, EXPECT_METHOD, true));
           if (!sink || isNot || !EXPECT_CAPTURE_EXPRESSIONS.has(expression)) {
-            return fn.apply(target, callArgs);
+            return callMethod(target, prop, callArgs);
           }
           sink.lastActivePage = page;
-          const callerLocation = captureCallerLocation();
           const used = {
             method: originMethod,
             args: originArgs,
@@ -3276,7 +4474,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
             seq = sink.capturedLocators.length;
             sink.capturedLocators.push({ location: callerLocation, used, element: null, alternatives: [] });
           }
-          const result = await fn.apply(target, callArgs);
+          const result = await callMethod(target, prop, callArgs);
           const matches = result?.matches;
           if (matches === true && !alreadyProbed) {
             if (callerLocation) sink.probedLocations.add(callerLocation);
@@ -3290,9 +4488,10 @@ function wrapLocator(page, locator, originMethod, originArgs) {
       if (!ACTION_METHOD_SET.has(prop)) return original;
       return async (...callArgs) => {
         const sink = currentSink;
-        if (!sink) return fn.apply(target, callArgs);
+        if (!sink) return callMethod(target, prop, callArgs);
         sink.lastActivePage = page;
         const callerLocation = captureCallerLocation();
+        recordLocatorPage(sink, page, target, callerLocation, noteLocatorCall(page, String(prop)));
         const used = {
           method: originMethod,
           args: originArgs,
@@ -3311,7 +4510,7 @@ function wrapLocator(page, locator, originMethod, originArgs) {
         }
         let result;
         try {
-          result = await fn.apply(target, callArgs);
+          result = await callMethod(target, prop, callArgs);
         } catch (error) {
           sink.failedLocators.push({ method: originMethod, args: originArgs, location: callerLocation });
           throw error;
@@ -3330,18 +4529,19 @@ function wrapFrameLocator(page, frameLocator) {
     get(target, prop) {
       const original = Reflect.get(target, prop);
       if (typeof original !== "function") return original;
-      const fn = original;
       if (!LOCATOR_METHOD_SET.has(prop)) return original;
       return (...args) => {
         if (currentSink) currentSink.lastActivePage = page;
-        return wrapLocator(page, fn.apply(target, args), String(prop), args);
+        return wrapLocator(page, callMethod(target, prop, args), String(prop), args);
       };
     }
   });
 }
+var CANCELLED_REQUEST = /^net::ERR_ABORTED$|^NS_BINDING_ABORTED$|^NS_ERROR_ABORT$|cancell?ed/i;
 function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
+  void maybeStartCodeReach(page);
   const probeSink = currentSink;
   if (probeSink?.probeItem && !probeSink.probeInterception) {
     void installProbeInterception(page, probeSink.probeItem).then((interception) => {
@@ -3349,6 +4549,18 @@ function instrumentPage(page) {
     }).catch(() => {
     });
   }
+  const flake = currentSink?.flake;
+  if (flake?.role === "target" && !flake.conditions) {
+    flake.browserName = pageBrowserName(page) ?? flake.browserName;
+    const plan = flake.plan;
+    flake.conditions = installFlakeConditions(page, plan).catch((error) => {
+      const note = `conditions failed to install: ${error instanceof Error ? error.message : String(error)}`;
+      const reports = unappliedReports(plan).map(
+        (r) => r.outcome === "by-command" ? r : { ...r, outcome: "skipped", note }
+      );
+      return { reports: () => reports };
+    });
+  }
   const ctx = pageContext(page);
   if (ctx) instrumentContext(ctx);
   if (typeof page.close === "function") {
@@ -3359,6 +4571,7 @@ function instrumentPage(page) {
       if (sink) {
         await stashPageState(sink, { page });
         await maybeOpenPicker(sink, { page });
+        await stopSinkCodeReach(sink, { page });
       }
       return originalClose(...args);
     };
@@ -3381,7 +4594,13 @@ function instrumentPage(page) {
       };
     }
     if (typeof page.on === "function") {
-      page.on("framenavigated", () => PROBE_UNSEEDED_PAGES.delete(page));
+      page.on("framenavigated", (frame) => {
+        PROBE_UNSEEDED_PAGES.delete(page);
+        try {
+          if (frame === page.mainFrame()) noteNavigation(page);
+        } catch {
+        }
+      });
     }
   }
   if (typeof page.on === "function" && process.env.PIWI_CAPTURE_PAGE_INVENTORY === "true") {
@@ -3424,7 +4643,7 @@ function instrumentPage(page) {
     } catch {
     }
   }
-  page.on("requestfinished", (request) => {
+  const recordRequest = (request, failed) => {
     const sink = currentSink;
     if (!sink) return;
     sink.lastActivePage = page;
@@ -3432,18 +4651,21 @@ function instrumentPage(page) {
       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;
+        if (!TRACKED_REQUEST_TYPES.includes(resourceType)) return;
+        const failure = failed ? request.failure()?.errorText ?? "failed" : null;
+        if (failure && CANCELLED_REQUEST.test(failure)) return;
+        const timing = request.timing();
+        const response = failed ? null : await request.response();
         const entry = {
           method: request.method(),
           url,
           status: response ? response.status() : 0,
-          duration: timing.responseEnd > 0 ? Math.round(timing.responseEnd - timing.requestStart) : 0,
+          duration: requestDuration(timing, failed),
           startTime: timing.startTime,
           resourceType
         };
+        if (failure) entry.failure = failure;
         if (response) {
           const headers = response.headers();
           const contentType = headers["content-type"];
@@ -3468,7 +4690,12 @@ function instrumentPage(page) {
       }
     })();
     sink.pendingHandlers.push(p);
-  });
+  };
+  page.on("requestfinished", (request) => recordRequest(request, false));
+  page.on("requestfailed", (request) => recordRequest(request, true));
+}
+async function awaitFlakeConditions() {
+  await currentSink?.flake?.conditions;
 }
 function instrumentContext(context) {
   if (!context || INSTRUMENTED_CONTEXTS.has(context)) return;
@@ -3481,6 +4708,8 @@ function instrumentContext(context) {
   context.newPage = async (...args) => {
     const page = await originalNewPage(...args);
     instrumentPage(page);
+    await awaitFlakeConditions();
+    await maybeStartCodeReach(page);
     return page;
   };
   if (typeof context.close === "function") {
@@ -3491,6 +4720,7 @@ function instrumentContext(context) {
       if (sink) {
         await stashPageState(sink, { context });
         await maybeOpenPicker(sink, { context });
+        await stopSinkCodeReach(sink, { context });
       }
       return originalClose(...args);
     };
@@ -3504,6 +4734,8 @@ function patchBrowser(browser) {
   browser.newPage = async (...args) => {
     const page = await originalNewPage(...args);
     instrumentPage(page);
+    await awaitFlakeConditions();
+    await maybeStartCodeReach(page);
     return page;
   };
   const originalNewContext = browser.newContext.bind(browser);
@@ -3520,13 +4752,25 @@ function patchBrowser(browser) {
     };
   }
 }
+function readRootAria(page) {
+  return internalCall(page, () => ariaSnapshotBestEffort(page.locator(":root")));
+}
+function readRootAriaJson(page) {
+  return internalCall(page, () => ariaSnapshotJSONBestEffort(page.locator(":root")));
+}
+var TRACKED_REQUEST_TYPES = ["fetch", "xhr", "document", "other"];
+function requestDuration(timing, failed) {
+  if (timing.responseEnd > 0) return Math.round(timing.responseEnd - timing.requestStart);
+  if (failed && timing.startTime > 0) return Math.max(0, Math.round(Date.now() - timing.startTime));
+  return 0;
+}
 async function flushSink(sink, testInfo) {
   await Promise.allSettled(sink.pendingHandlers);
   let drainDeadline;
   await Promise.race([
     Promise.allSettled(sink.capturePromises),
-    new Promise((resolve) => {
-      drainDeadline = setTimeout(resolve, 2e3);
+    new Promise((resolve3) => {
+      drainDeadline = setTimeout(resolve3, 2e3);
     })
   ]);
   clearTimeout(drainDeadline);
@@ -3542,15 +4786,28 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(dedupeSnapshotsByLocation(sink.capturedLocators)))
     });
   }
+  await stopSinkCodeReach(sink);
+  if (sink.codeReach?.files?.length) {
+    await testInfo.attach(ATTACHMENT_NAMES.codeReach, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.codeReach.files))
+    });
+  }
+  if (sink.locatorPages.size > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.locatorPages, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.locatorPages.list()))
+    });
+  }
   if (testInfo.status !== "passed" && testInfo.status !== "skipped") {
     try {
-      const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(":root")) : null) ?? sink.stashedAria;
+      const snapshot = (pageReadable ? await readRootAria(page) : null) ?? sink.stashedAria;
       if (snapshot) {
         await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
           contentType: "text/plain",
           body: snapshot
         });
-        const snapshotJson = (pageReadable ? await ariaSnapshotJSONBestEffort(page.locator(":root")) : null) ?? sink.stashedAriaJson;
+        const snapshotJson = (pageReadable ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
         if (snapshotJson) {
           await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
             contentType: "application/json",
@@ -3575,13 +4832,13 @@ async function flushSink(sink, testInfo) {
   }
   if (testInfo.status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && isDueForAriaSample(testInfo)) {
     try {
-      const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(":root")) : null) ?? sink.stashedAria;
+      const snapshot = (pageReadable ? await readRootAria(page) : null) ?? sink.stashedAria;
       if (snapshot) {
         await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
           contentType: "text/plain",
           body: snapshot
         });
-        const snapshotJson = (pageReadable ? await ariaSnapshotJSONBestEffort(page.locator(":root")) : null) ?? sink.stashedAriaJson;
+        const snapshotJson = (pageReadable ? await readRootAriaJson(page) : null) ?? sink.stashedAriaJson;
         if (snapshotJson) {
           await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
             contentType: "application/json",
@@ -3627,7 +4884,7 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(sink.networkRequests))
     });
   }
-  const webVitals = (pageReadable ? await readWebVitals(page) : null) ?? sink.stashedWebVitals;
+  const webVitals = (pageReadable ? await internalCall(page, () => readWebVitals(page)) : null) ?? sink.stashedWebVitals;
   if (webVitals) {
     await testInfo.attach(ATTACHMENT_NAMES.webVitals, {
       contentType: "application/json",
@@ -3635,7 +4892,7 @@ async function flushSink(sink, testInfo) {
     });
   }
   if (process.env.PIWI_CAPTURE_PAGE_STATE !== "false") {
-    const pageState = (pageReadable ? await readPageState(page) : null) ?? sink.stashedPageState;
+    const pageState = (pageReadable ? await internalCall(page, () => readPageState(page)) : null) ?? sink.stashedPageState;
     if (pageState) {
       await testInfo.attach(ATTACHMENT_NAMES.pageState, {
         contentType: "application/json",
@@ -3669,6 +4926,8 @@ var piwiFixtures = {
   // never double-wraps a page the browser patch already instrumented.
   page: async ({ page }, use) => {
     instrumentPage(page);
+    await awaitFlakeConditions();
+    await maybeStartCodeReach(page);
     await use(page);
   },
   // Auto, test-scoped: open a capture sink for the running test and flush it
@@ -3676,8 +4935,24 @@ var piwiFixtures = {
   // requested, so suites that never destructure `page` are still captured.
   piwiCapture: [
     async ({}, use, testInfo) => {
+      boxCaptureFrames();
+      const conflict = labModeConflict();
+      if (conflict) throw new Error(conflict);
       const sink = createSink();
       sink.testInfo = testInfo;
+      if (isFlakeMode()) {
+        const plan = loadFlakePlan();
+        const role = flakeRoleForTest(plan, {
+          file: testInfo.file,
+          title: testInfo.title,
+          titlePath: testInfo.titlePath,
+          project: testInfo.project.name
+        });
+        if (role) {
+          const browserName = testInfo.project.use?.browserName ?? null;
+          sink.flake = { plan, role, startedAt: Date.now(), browserName, conditions: null };
+        }
+      }
       if (isProbeMode())
         sink.probeItem = probeItemForTest({
           title: testInfo.title,
@@ -3708,23 +4983,57 @@ var piwiFixtures = {
             handled
           });
         }
+        if (sink.flake) await recordFlakeAttempt(sink.flake, testInfo);
         await flushSink(sink, testInfo);
       }
     },
     { auto: true }
   ]
 };
+async function recordFlakeAttempt(flake, testInfo) {
+  const installed = flake.conditions ? await flake.conditions : null;
+  recordFlakeResult(
+    flakeResultLine(flake.plan, {
+      role: flake.role,
+      file: testInfo.file,
+      title: testInfo.title,
+      project: testInfo.project.name || null,
+      browserName: flake.browserName,
+      status: testInfo.status ?? "passed",
+      errorText: joinErrorMessages(testInfo.errors),
+      startedAt: flake.startedAt,
+      duration: Date.now() - flake.startedAt,
+      workerIndex: testInfo.workerIndex,
+      parallelIndex: testInfo.parallelIndex,
+      repeatEachIndex: testInfo.repeatEachIndex,
+      retry: testInfo.retry,
+      conditions: installed ? installed.reports() : unappliedReports(flake.plan)
+    })
+  );
+}
 function extendPiwiFixtures(test) {
   return test.extend(piwiFixtures);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CAPTURED_ATTRS_ARG,
+  LocatorPageLog,
   ariaSnapshotBestEffort,
   ariaSnapshotJSONBestEffort,
+  boxCaptureFrames,
   buildPageState,
+  callMethod,
+  codeReachRoots,
   computeCoreVitals,
+  configuredCodeReachRoots,
   extendPiwiFixtures,
+  internalCall,
+  noteLocatorCall,
+  noteNavigation,
+  pageMapFetcher,
   piwiFixtures,
-  probeElementAttrs
+  probeElementAttrs,
+  resolveCodeReach,
+  startCodeReach,
+  stopCodeReach
 });