@piwitests/reporter 0.35.0 → 0.38.0

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

@@ -40,7 +40,7 @@ __export(capture_fixtures_exports, {
   probeElementAttrs: () => probeElementAttrs
 });
 module.exports = __toCommonJS(capture_fixtures_exports);
-var import_node_zlib = require("zlib");
+var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
 function probeElementAttrs(el, arg) {
@@ -1742,6 +1742,7 @@ var ATTACHMENT_NAMES = {
   console: "piwi-console",
   dialogs: "piwi-dialogs",
   network: "piwi-network",
+  pageInventory: "piwi-page-inventory",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
   pageState: "piwi-page-state",
@@ -1753,6 +1754,512 @@ 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/page-inventory.ts
+var PAGE_INVENTORY_MAX_ENTRIES = 500;
+function collectPageInventoryInPage(maxEntries) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || !g.location) return null;
+  const clean = (s) => (s || "").replace(/\s+/g, " ").trim().slice(0, 120);
+  const roleOf = (el) => {
+    const explicit = el.getAttribute("role");
+    if (explicit) return explicit.toLowerCase();
+    const tag = (el.tagName || "").toLowerCase();
+    if (tag === "a") return el.getAttribute("href") != null ? "link" : "generic";
+    if (tag === "button") return "button";
+    if (tag === "select") return el.hasAttribute("multiple") ? "listbox" : "combobox";
+    if (tag === "textarea") return "textbox";
+    if (tag === "input") {
+      const type = (el.getAttribute("type") || "text").toLowerCase();
+      const map = {
+        checkbox: "checkbox",
+        radio: "radio",
+        button: "button",
+        submit: "button",
+        reset: "button",
+        image: "button",
+        range: "slider",
+        search: "searchbox",
+        email: "textbox",
+        tel: "textbox",
+        url: "textbox",
+        number: "spinbutton"
+      };
+      return map[type] || "textbox";
+    }
+    return "generic";
+  };
+  const holdsValue = (el, role) => {
+    const tag = (el.tagName || "").toLowerCase();
+    if (tag === "select" || tag === "textarea" || tag === "input") return true;
+    if (el.isContentEditable === true) return true;
+    const editable = el.getAttribute("contenteditable");
+    if (editable === "" || editable === "true") return true;
+    return role === "textbox" || role === "combobox" || role === "listbox" || role === "searchbox" || role === "spinbutton";
+  };
+  const labelText = (el) => {
+    const labels = el.labels;
+    if (!labels || labels.length === 0) return "";
+    let text = "";
+    for (const label of labels) text += ` ${label.textContent || ""}`;
+    return text;
+  };
+  const labelledByText = (el) => {
+    const ids = (el.getAttribute("aria-labelledby") || "").split(/\s+/).filter(Boolean);
+    if (ids.length === 0) return "";
+    let text = "";
+    for (const id of ids) {
+      const ref = doc.getElementById(id);
+      if (ref) text += ` ${ref.textContent || ""}`;
+    }
+    return text;
+  };
+  const nameOf = (el) => {
+    const role = roleOf(el);
+    const chain = [el.getAttribute("aria-label"), labelledByText(el), labelText(el)];
+    if (!holdsValue(el, role)) chain.push(el.textContent);
+    chain.push(el.getAttribute("placeholder"), el.getAttribute("title"), el.getAttribute("alt"));
+    return clean(chain.find((s) => s && String(s).trim()) || "");
+  };
+  const cleanHref = (href) => {
+    const cut = href.search(/[?#]/);
+    return cut >= 0 ? href.slice(0, cut) : href;
+  };
+  const controls = [];
+  const links = [];
+  const seenC = /* @__PURE__ */ new Set();
+  const seenL = /* @__PURE__ */ new Set();
+  let budget = maxEntries;
+  const controlSelector = 'button, [role="button"], input, select, textarea, [role="checkbox"], [role="radio"], [role="tab"], [role="menuitem"], [role="combobox"], [role="switch"], [role="slider"], [role="searchbox"], [role="spinbutton"], [role="textbox"], [role="listbox"]';
+  for (const el of Array.from(doc.querySelectorAll(controlSelector))) {
+    if (budget <= 0) break;
+    const role = roleOf(el);
+    const name = nameOf(el);
+    if (!name) continue;
+    const key = `${role}\0${name}`;
+    if (seenC.has(key)) continue;
+    seenC.add(key);
+    controls.push({ role, name });
+    budget--;
+  }
+  for (const el of Array.from(doc.querySelectorAll("a[href]"))) {
+    if (budget <= 0) break;
+    const name = nameOf(el);
+    const href = cleanHref(el.getAttribute("href") || "");
+    if (!name) continue;
+    const key = `${name}\0${href}`;
+    if (seenL.has(key)) continue;
+    seenL.add(key);
+    links.push({ name, href });
+    budget--;
+  }
+  return { url: g.location.href, controls, links };
+}
+function capPageInventory(inventory, max = PAGE_INVENTORY_MAX_ENTRIES) {
+  const controls = inventory.controls.slice(0, Math.max(0, max));
+  const links = inventory.links.slice(0, Math.max(0, max - controls.length));
+  return { url: inventory.url, controls, links, capturedAt: inventory.capturedAt };
+}
+function inventoryPageKey(url) {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return null;
+  }
+}
+
+// src/internal/probe/mode.ts
+var fs2 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+
+// src/internal/config/desktop.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+
+// src/internal/config/env.ts
+var DEFAULTS = {
+  projectName: "default-project",
+  uploadTraces: true,
+  uploadReport: true,
+  liveFileUploads: true,
+  collectScmInfo: true,
+  collectCiInfo: true,
+  collectPerformanceMetrics: true,
+  captureLocators: true,
+  capturePageState: true,
+  // 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,
+  captureServerTraces: true,
+  sampleAriaOnPass: true,
+  uploadManifest: true,
+  defaultCapture: true,
+  streaming: true,
+  streamingBatchSize: 5,
+  streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
+  failOnFlakyTests: false,
+  username: null,
+  password: null,
+  apiKey: null,
+  verbose: false
+};
+var PIWI_ENV_KEYS = {
+  serverUrl: "PIWI_DASHBOARD_URL",
+  projectName: "PIWI_PROJECT_NAME",
+  verbose: "PIWI_VERBOSE",
+  apiKey: "PIWI_API_KEY",
+  username: "PIWI_USERNAME",
+  password: "PIWI_PASSWORD",
+  environment: "PIWI_ENVIRONMENT",
+  label: "PIWI_LABEL",
+  runLabel: "PIWI_RUN_LABEL",
+  keep: "PIWI_KEEP",
+  streaming: "PIWI_STREAMING",
+  streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
+  streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
+  maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
+  liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
+  failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
+  uploadTraces: "PIWI_UPLOAD_TRACES",
+  uploadReport: "PIWI_UPLOAD_REPORT",
+  captureLocators: "PIWI_CAPTURE_LOCATORS",
+  capturePageState: "PIWI_CAPTURE_PAGE_STATE",
+  capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
+  captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
+  uploadManifest: "PIWI_UPLOAD_MANIFEST",
+  defaultCapture: "PIWI_DEFAULT_CAPTURE",
+  inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
+  pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
+  outputFile: "PIWI_OUTPUT_FILE",
+  aiMode: "PIWI_AI",
+  aiDir: "PIWI_AI_DIR",
+  aiOnMiss: "PIWI_AI_ON_MISS",
+  aiMaxSteps: "PIWI_AI_MAX_FLOW_STEPS",
+  aiMaxSnapshotChars: "PIWI_AI_MAX_SNAPSHOT_CHARS",
+  aiOptionalProbeTimeout: "PIWI_AI_OPTIONAL_PROBE_TIMEOUT",
+  aiResponseWaitTimeout: "PIWI_AI_RESPONSE_WAIT_TIMEOUT",
+  aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
+};
+var PIWI_PROBE_ENV = {
+  flag: "PIWI_PROBE",
+  plan: "PIWI_PROBE_PLAN",
+  results: "PIWI_PROBE_RESULTS",
+  secret: "PIWI_PROBE_SECRET"
+};
+var ENV_FALLBACK_SPECS = [
+  { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
+  { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
+  { option: "apiKey", env: PIWI_ENV_KEYS.apiKey, kind: "string" },
+  { option: "username", env: PIWI_ENV_KEYS.username, kind: "string" },
+  { option: "password", env: PIWI_ENV_KEYS.password, kind: "string" },
+  { option: "environment", env: PIWI_ENV_KEYS.environment, kind: "string" },
+  { option: "label", env: PIWI_ENV_KEYS.label, kind: "string" },
+  { option: "runLabel", env: PIWI_ENV_KEYS.runLabel, kind: "string" },
+  { option: "keep", env: PIWI_ENV_KEYS.keep, kind: "bool" },
+  { option: "streaming", env: PIWI_ENV_KEYS.streaming, kind: "bool" },
+  { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
+  { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
+  { option: "maxStreamBufferBytes", env: PIWI_ENV_KEYS.maxStreamBufferBytes, kind: "number" },
+  { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
+  { option: "failOnFlakyTests", env: PIWI_ENV_KEYS.failOnFlakyTests, kind: "bool" },
+  { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
+  { option: "uploadReport", env: PIWI_ENV_KEYS.uploadReport, kind: "bool" },
+  { 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: "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" },
+  { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
+  { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
+  { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
+  { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
+];
+
+// 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 patternToRegex(pattern) {
+  const path6 = pattern.split("?")[0] ?? pattern;
+  const escaped = path6.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z0-9_]+/g, "[^/]+");
+  return new RegExp(`^${escaped}$`);
+}
+function suitePathEqual(a, b) {
+  if (!a || !b || a.length !== b.length) return false;
+  return a.every((title, i) => title === b[i]);
+}
+function matchProbeItem(plan, test) {
+  const byFileTitle = plan.items.filter(
+    (item) => item.filePath && test.filePath && item.filePath === test.filePath && item.testTitle === test.title
+  );
+  if (byFileTitle.length === 1) return byFileTitle[0];
+  if (byFileTitle.length > 1) {
+    return byFileTitle.find((item) => suitePathEqual(item.suitePath, test.suitePath)) ?? byFileTitle[0];
+  }
+  for (const item of plan.items) {
+    if (!item.filePath && item.testTitle && test.title && item.testTitle === test.title) return item;
+  }
+  return null;
+}
+function requestMatchesRoute(method, url, routeKey) {
+  const { method: rm, pattern } = parseRouteKey(routeKey);
+  if (rm && rm !== method.toUpperCase()) return false;
+  let path6;
+  try {
+    path6 = new URL(url).pathname;
+  } catch {
+    path6 = url.split("?")[0] ?? url;
+  }
+  return patternToRegex(pattern).test(path6);
+}
+function createProbeState() {
+  return { navigated: false, matches: 0 };
+}
+function markNavigated(state) {
+  state.navigated = true;
+}
+function shouldMutate(state, item) {
+  if (!state.navigated) return false;
+  state.matches += 1;
+  return state.matches === Math.max(1, item.nth ?? 1);
+}
+
+// src/internal/probe/mode.ts
+var planCache;
+function isProbeMode() {
+  return process.env[PIWI_PROBE_ENV.flag] === "1" || process.env[PIWI_PROBE_ENV.flag] === "true";
+}
+function loadPlan() {
+  if (planCache !== void 0) return planCache;
+  planCache = null;
+  const path6 = process.env[PIWI_PROBE_ENV.plan];
+  if (path6) {
+    try {
+      planCache = JSON.parse(fs2.readFileSync(path6, "utf8"));
+    } catch {
+      planCache = null;
+    }
+  }
+  return planCache;
+}
+function probeItemForTest(test) {
+  const plan = loadPlan();
+  if (!plan) return null;
+  const filePath = test.file ? path3.relative(process.cwd(), test.file).split(path3.sep).join("/") : null;
+  const suitePath = test.titlePath ? test.titlePath.slice(1, -1) : void 0;
+  return matchProbeItem(plan, { title: test.title, filePath, suitePath });
+}
+function classifyProbeHandled(signals) {
+  return signals.consoleErrors > 0 || signals.dialogs > 0 || signals.backendError ? "degraded" : "graceful";
+}
+function outcomeFromStatus(status, applied) {
+  if (!applied) return "inconclusive";
+  return status === "failed" || status === "timedOut" || status === "interrupted" ? "noticed" : "not-noticed";
+}
+function recordProbeOutcome(line) {
+  const path6 = process.env[PIWI_PROBE_ENV.results];
+  if (!path6) return;
+  try {
+    fs2.appendFileSync(path6, `${JSON.stringify(line)}
+`);
+  } catch {
+  }
+}
+
+// src/internal/probe/interception.ts
+var import_node_zlib = require("zlib");
+
+// src/internal/probe/faults.ts
+var PROBE_FAULTS = ["status-500", "empty-body", "drop-field", "stale-value", "slow"];
+var SERVER_PROBE_FAULTS = [
+  "throw",
+  "status",
+  "delay",
+  "dependency",
+  "data",
+  "extreme",
+  "replay",
+  "auth",
+  "slow-first"
+];
+function isFaultAllowed(level, fault) {
+  const list = level === "server" ? SERVER_PROBE_FAULTS : PROBE_FAULTS;
+  return list.includes(fault);
+}
+var SLOW_FAULT_DELAY_MS = 5e3;
+function dropOneField(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return body;
+  }
+  if (Array.isArray(parsed)) {
+    let key;
+    for (const el of parsed) {
+      if (el && typeof el === "object" && !Array.isArray(el)) {
+        key ??= Object.keys(el)[0];
+        if (key) delete el[key];
+      }
+    }
+    return JSON.stringify(parsed);
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed;
+    const key = Object.keys(obj)[0];
+    if (key) delete obj[key];
+    return JSON.stringify(obj);
+  }
+  return body;
+}
+function computeFault(fault, input) {
+  const base = {
+    status: input.status,
+    body: input.body,
+    contentType: input.contentType ?? null,
+    delayMs: 0,
+    changed: false
+  };
+  switch (fault) {
+    case "status-500":
+      return { ...base, status: 500, changed: input.status !== 500 };
+    case "empty-body":
+      return { ...base, body: "", changed: input.body.length > 0 };
+    case "drop-field": {
+      const body = dropOneField(input.body);
+      return { ...base, body, changed: body !== input.body };
+    }
+    case "stale-value": {
+      const body = input.priorBody ?? input.body;
+      return { ...base, body, changed: body !== input.body };
+    }
+    case "slow":
+      return { ...base, delayMs: SLOW_FAULT_DELAY_MS, changed: true };
+    default:
+      return base;
+  }
+}
+
+// src/internal/probe/sign.ts
+var import_node_crypto = require("crypto");
+function signProbeMessage(secret, nonce, ts, specJson) {
+  return (0, import_node_crypto.createHmac)("sha256", secret).update(`${nonce}.${ts}.${specJson}`).digest("hex");
+}
+function buildProbeHeader(secret, spec, now = Date.now()) {
+  const nonce = (0, import_node_crypto.randomBytes)(8).toString("hex");
+  const specJson = JSON.stringify(spec);
+  const sig = signProbeMessage(secret, nonce, now, specJson);
+  return Buffer.from(JSON.stringify({ nonce, ts: now, specJson, sig }), "utf8").toString("base64");
+}
+
+// src/internal/probe/interception.ts
+function parseProbeTrace(traceHeader) {
+  const none = { appliedFault: null, serverError: false };
+  if (!traceHeader) return none;
+  try {
+    const spans = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf8"));
+    if (!Array.isArray(spans)) return none;
+    const root = spans.find((s) => s && typeof s === "object" && !s.parentId);
+    if (!root) return none;
+    const attrs = root.attrs ?? {};
+    const appliedRaw = attrs["piwi.probe.applied"];
+    const status = Number(attrs["http.status_code"]) || 0;
+    return {
+      appliedFault: appliedRaw != null ? String(appliedRaw) : null,
+      serverError: root.status === "error" || status >= 500
+    };
+  } catch {
+    return none;
+  }
+}
+function fulfillHeaders(responseHeaders, contentType) {
+  const headers = { ...responseHeaders };
+  delete headers["content-length"];
+  delete headers["content-encoding"];
+  if (contentType) headers["content-type"] = contentType;
+  return headers;
+}
+function originOf(url) {
+  try {
+    const origin = new URL(url).origin;
+    return origin && origin !== "null" ? origin : null;
+  } catch {
+    return null;
+  }
+}
+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;
+  let appOrigin = null;
+  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 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();
+        return;
+      }
+      const spec = { route: item.routeKey, fault: item.fault, nth: item.nth };
+      if (item.dependency) spec.dependency = item.dependency;
+      try {
+        const response = await route.fetch({
+          headers: { ...request.headers(), "x-piwi-probe": buildProbeHeader(probeSecret, spec) }
+        });
+        const trace = parseProbeTrace(response.headers()["x-piwi-trace"]);
+        appliedFault = trace.appliedFault;
+        serverError = trace.serverError;
+        applied = trace.appliedFault != null && trace.appliedFault.split(":", 1)[0] === item.fault;
+        await route.fulfill({ response });
+      } catch {
+        applied = false;
+        await route.fallback();
+      }
+      return;
+    }
+    try {
+      const response = await route.fetch();
+      const body = await response.text();
+      const out = computeFault(item.fault, {
+        status: response.status(),
+        body,
+        contentType: response.headers()["content-type"] ?? null
+      });
+      applied = out.changed;
+      if (applied) appliedFault = item.fault;
+      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";
@@ -1789,88 +2296,295 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // 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;
+var path4 = __toESM(require("path"));
+
+// ../core/src/locator-chain.ts
+var LOCATING_METHODS = /* @__PURE__ */ new Set([
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator",
+  "frameLocator"
+]);
+var NARROWING_METHODS = /* @__PURE__ */ new Set([
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "visible",
+  "contentFrame",
+  "owner"
+]);
+var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([...LOCATING_METHODS, ...NARROWING_METHODS]);
+var LocatorParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LocatorParseError";
   }
-  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;
+};
+var SIMPLE_ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0"
+};
+var Parser = class {
+  constructor(src) {
+    this.src = src;
+    this.i = 0;
+  }
+  parseTopLevel() {
+    const chain = this.parseChain();
+    this.skipSpace();
+    if (this.i < this.src.length) this.fail("unexpected text");
+    return chain;
+  }
+  fail(message) {
+    throw new LocatorParseError(`${message} at "${this.src.slice(this.i, this.i + 20)}"`);
+  }
+  skipSpace() {
+    while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i++;
+  }
+  peek() {
+    return this.src[this.i];
+  }
+  expect(ch) {
+    this.skipSpace();
+    if (this.src[this.i] !== ch) this.fail(`expected "${ch}"`);
+    this.i++;
+  }
+  identifier() {
+    const m = /^[A-Za-z_$][\w$]*/.exec(this.src.slice(this.i));
+    if (!m) this.fail("expected a name");
+    this.i += m[0].length;
+    return m[0];
+  }
+  /**
+   * A chain of calls joined by `.`. With `lenient`, parsing stops before the
+   * first link that doesn't parse instead of failing, so a chain followed by
+   * other text (an error message) is read up to where it ends. `spans` receives
+   * where each top-level call starts and ends.
+   */
+  parseChain(opts = {}) {
+    this.skipSpace();
+    const calls = [];
+    for (; ; ) {
+      const before = this.i;
+      if (calls.length > 0) this.i++;
+      this.skipSpace();
+      const start = this.i;
+      try {
+        calls.push(this.parseCall(calls.length === 0));
+      } catch (error) {
+        if (!opts.lenient || calls.length === 0) throw error;
+        this.i = before;
+        break;
+      }
+      opts.spans?.push({ start, end: this.i });
+      const end = this.i;
+      this.skipSpace();
+      if (this.peek() !== ".") {
+        this.i = end;
+        break;
+      }
     }
-    if (c === "{") {
-      const end = matchBrace(inner, i);
-      args.push(parseOptions(inner.slice(i, end + 1)));
-      i = end + 1;
-      continue;
+    return { calls };
+  }
+  /** Where the parser stopped. */
+  get position() {
+    return this.i;
+  }
+  parseCall(first) {
+    this.skipSpace();
+    const method = this.identifier();
+    if (!LOCATOR_CHAIN_METHODS.has(method)) this.fail(`unsupported method ${method}()`);
+    if (first && !LOCATING_METHODS.has(method)) this.fail(`${method}() needs a locator before it`);
+    this.expect("(");
+    const args = [];
+    this.skipSpace();
+    if (this.peek() === ")") {
+      this.i++;
+      return { method, args };
+    }
+    for (; ; ) {
+      args.push(this.parseValue());
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        this.skipSpace();
+        if (this.peek() === ")") {
+          this.i++;
+          break;
+        }
+        continue;
+      }
+      this.expect(")");
+      break;
+    }
+    return { method, args };
+  }
+  parseValue() {
+    this.skipSpace();
+    const ch = this.peek();
+    if (ch === "'" || ch === '"' || ch === "`") return { type: "string", value: this.parseString() };
+    if (ch === "/") return this.parseRegex();
+    if (ch === "{") return this.parseObject();
+    if (ch !== void 0 && /[-\d]/.test(ch)) {
+      const m = /^-?\d+(?:\.\d+)?/.exec(this.src.slice(this.i));
+      if (!m) this.fail("expected a number");
+      this.i += m[0].length;
+      return { type: "number", value: Number(m[0]) };
+    }
+    const rest = this.src.slice(this.i);
+    if (/^true\b/.test(rest)) {
+      this.i += 4;
+      return { type: "boolean", value: true };
+    }
+    if (/^false\b/.test(rest)) {
+      this.i += 5;
+      return { type: "boolean", value: false };
+    }
+    if (/^[A-Za-z_$]/.test(rest)) return { type: "chain", chain: this.parseChain() };
+    return this.fail("expected a value");
+  }
+  /** A quoted string, decoding the escapes `JSON.stringify` and JavaScript produce. */
+  parseString() {
+    const quote = this.src[this.i];
+    let out = "";
+    this.i++;
+    while (this.i < this.src.length) {
+      const c = this.src[this.i];
+      if (c === quote) {
+        this.i++;
+        return out;
+      }
+      if (c !== "\\") {
+        out += c;
+        this.i++;
+        continue;
+      }
+      const next = this.src[this.i + 1];
+      if (next === void 0) break;
+      const simple = SIMPLE_ESCAPES[next];
+      if (simple !== void 0) {
+        out += simple;
+        this.i += 2;
+        continue;
+      }
+      const hex = next === "u" && this.src[this.i + 2] === "{" ? /^u\{([0-9a-fA-F]{1,6})\}/.exec(this.src.slice(this.i + 1)) : next === "u" ? /^u([0-9a-fA-F]{4})/.exec(this.src.slice(this.i + 1)) : next === "x" ? /^x([0-9a-fA-F]{2})/.exec(this.src.slice(this.i + 1)) : null;
+      if (hex) {
+        out += String.fromCodePoint(parseInt(hex[1], 16));
+        this.i += 1 + hex[0].length;
+        continue;
+      }
+      if (next === "u" || next === "x") this.fail("malformed escape");
+      out += next;
+      this.i += 2;
+    }
+    return this.fail("unterminated string");
+  }
+  parseRegex() {
+    let j = this.i + 1;
+    let inClass = false;
+    while (j < this.src.length) {
+      const c = this.src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "[") inClass = true;
+      else if (c === "]") inClass = false;
+      else if (c === "/" && !inClass) break;
+      j++;
+    }
+    if (j >= this.src.length) this.fail("unterminated regex");
+    const source = this.src.slice(this.i + 1, j);
+    const flags = /^[a-z]*/.exec(this.src.slice(j + 1))[0];
+    this.i = j + 1 + flags.length;
+    return { type: "regex", source, flags };
+  }
+  parseObject() {
+    this.expect("{");
+    const entries = [];
+    for (; ; ) {
+      this.skipSpace();
+      if (this.peek() === "}") {
+        this.i++;
+        break;
+      }
+      const ch = this.peek();
+      const key = ch === "'" || ch === '"' ? this.parseString() : this.identifier();
+      this.expect(":");
+      entries.push([key, this.parseValue()]);
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        continue;
+      }
+      this.expect("}");
+      break;
     }
-    i++;
+    return { type: "object", entries };
   }
-  return args;
+};
+function parseLocatorChain(expr) {
+  const trimmed = expr.trim().replace(/^(?:await\s+)?(?:this\.)?page\./, "");
+  if (!trimmed) throw new LocatorParseError("empty expression");
+  return new Parser(trimmed).parseTopLevel();
 }
-function 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;
-    }
+function tryParseLocatorChain(expr) {
+  try {
+    return parseLocatorChain(expr);
+  } catch {
+    return null;
   }
-  return expr.slice(leafStart);
 }
+function parseLeafLocatorCall(expr) {
+  const chain = tryParseLocatorChain(expr);
+  if (!chain) return null;
+  for (let i = chain.calls.length - 1; i >= 0; i--) {
+    if (LOCATING_METHODS.has(chain.calls[i].method)) return chain.calls[i];
+  }
+  return null;
+}
+function locatorCallValues(call, opts = {}) {
+  const value = (arg) => {
+    switch (arg.type) {
+      case "string":
+      case "number":
+      case "boolean":
+        return arg.value;
+      case "regex":
+        return opts.regexAsText ? `/${arg.source}/${arg.flags}` : void 0;
+      case "object": {
+        const out = {};
+        for (const [key, v] of arg.entries) {
+          const plain = value(v);
+          if (plain !== void 0) out[key] = plain;
+        }
+        return out;
+      }
+      case "chain":
+        return void 0;
+    }
+  };
+  return call.args.map(value).filter((v) => v !== void 0);
+}
+
+// src/internal/capture/pick-on-failure.ts
+var ANSI_RE = /\[[0-9;]*m/g;
 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()) };
+  const leaf = parseLeafLocatorCall(rawExpr);
+  return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
 }
 function deriveFailedLocator(testInfo) {
   const info = testInfo;
@@ -1883,7 +2597,7 @@ ${err.stack ?? ""}`.replace(ANSI_RE, "");
     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;
+    const location = loc ? `${path4.relative(process.cwd(), loc.file).split(path4.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed.method, args: parsed.args, location };
   }
   return null;
@@ -2032,13 +2746,13 @@ function applyPickToSnapshots(snapshots, pick) {
 }
 
 // src/internal/support/aria-sampling.ts
-var path3 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
-var fs = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var fs3 = __toESM(require("fs"));
 
 // src/internal/support/instance-id.ts
 var crypto = __toESM(require("crypto"));
-var os = __toESM(require("os"));
+var os2 = __toESM(require("os"));
 function hashForProject(projectName) {
   return crypto.createHash("sha1").update(projectName).digest("hex").slice(0, 16);
 }
@@ -2048,14 +2762,14 @@ function ariaSampleIdentity(filePath, title) {
   return `${filePath}\0${title}`;
 }
 function getAriaSampleFilePath(projectName) {
-  return path3.join(os2.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+  return path5.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 = fs.readFileSync(getAriaSampleFilePath(projectName), "utf8");
+    const raw = fs3.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"));
@@ -2067,7 +2781,7 @@ function loadAriaSampleSet(projectName) {
   return set;
 }
 function relativeTestFile(file) {
-  return path3.relative(process.cwd(), file).split(path3.sep).join("/");
+  return path5.relative(process.cwd(), file).split(path5.sep).join("/");
 }
 function isDueForAriaSample(testInfo) {
   const projectName = process.env.PIWI_PROJECT_NAME;
@@ -2123,6 +2837,9 @@ function createSink() {
     stashedPageState: null,
     stashedAria: null,
     stashedAriaJson: null,
+    pageInventories: [],
+    probeItem: null,
+    probeInterception: null,
     pickOffered: false,
     userPick: null
   };
@@ -2299,6 +3016,62 @@ async function readPageState(page) {
     return null;
   }
 }
+var inventoriedPageKeys = /* @__PURE__ */ new Set();
+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) => {
+    const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+async function readPageInventory(page) {
+  try {
+    const inventory = await withTimeout(
+      page.evaluate(collectPageInventoryInPage, PAGE_INVENTORY_IN_PAGE_CAP),
+      PAGE_INVENTORY_EVAL_TIMEOUT_MS
+    );
+    return inventory ? { ...inventory, capturedAt: Date.now() } : null;
+  } catch {
+    return null;
+  }
+}
+async function recordPageWindow(sink, page) {
+  if (sink.pageInventories.length >= MAX_PAGE_INVENTORY_WINDOWS) return;
+  let url;
+  try {
+    url = page.url();
+  } catch {
+    return;
+  }
+  if (!url || url.startsWith("about:")) return;
+  const key = inventoryPageKey(url);
+  const capturedAt = Date.now();
+  if (sink.pageInventories.length >= MAX_PAGE_INVENTORY_WINDOWS) return;
+  if (key && !inventoriedPageKeys.has(key)) {
+    inventoriedPageKeys.add(key);
+    const content = await readPageInventory(page);
+    if (sink.pageInventories.length >= MAX_PAGE_INVENTORY_WINDOWS) return;
+    sink.pageInventories.push({
+      url: content?.url ?? url,
+      controls: content?.controls ?? [],
+      links: content?.links ?? [],
+      capturedAt
+    });
+    return;
+  }
+  sink.pageInventories.push({ url, controls: [], links: [], capturedAt });
+}
 async function stashPageState(sink, closing) {
   const page = sink.lastActivePage;
   if (!page || isPageClosed(page)) return;
@@ -2323,6 +3096,9 @@ async function stashPageState(sink, closing) {
   } else if (status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && sink.testInfo && isDueForAriaSample(sink.testInfo)) {
     await sampleAria();
   }
+  if (status === "passed" && process.env.PIWI_CAPTURE_PAGE_INVENTORY === "true") {
+    await recordPageWindow(sink, page);
+  }
 }
 async function maybeOpenPicker(sink, closing) {
   if (sink.pickOffered) return;
@@ -2566,6 +3342,13 @@ function wrapFrameLocator(page, frameLocator) {
 function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
+  const probeSink = currentSink;
+  if (probeSink?.probeItem && !probeSink.probeInterception) {
+    void installProbeInterception(page, probeSink.probeItem).then((interception) => {
+      probeSink.probeInterception = interception;
+    }).catch(() => {
+    });
+  }
   const ctx = pageContext(page);
   if (ctx) instrumentContext(ctx);
   if (typeof page.close === "function") {
@@ -2601,6 +3384,14 @@ function instrumentPage(page) {
       page.on("framenavigated", () => PROBE_UNSEEDED_PAGES.delete(page));
     }
   }
+  if (typeof page.on === "function" && process.env.PIWI_CAPTURE_PAGE_INVENTORY === "true") {
+    page.on("framenavigated", (frame) => {
+      const sink = currentSink;
+      if (!sink || frame !== page.mainFrame()) return;
+      void recordPageWindow(sink, page).catch(() => {
+      });
+    });
+  }
   page.on("console", (msg) => {
     const sink = currentSink;
     if (!sink) return;
@@ -2660,14 +3451,14 @@ function instrumentPage(page) {
           const logHeader = headers["x-piwi-logs"];
           if (logHeader) {
             try {
-              entry.serverLogs = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
+              entry.serverLogs = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(logHeader, "base64")).toString("utf-8"));
             } catch {
             }
           }
           const traceHeader = headers["x-piwi-trace"];
           if (traceHeader && process.env.PIWI_CAPTURE_SERVER_TRACES !== "false") {
             try {
-              entry.serverTraces = JSON.parse((0, import_node_zlib.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
+              entry.serverTraces = JSON.parse((0, import_node_zlib2.gunzipSync)(Buffer.from(traceHeader, "base64")).toString("utf-8"));
             } catch {
             }
           }
@@ -2852,6 +3643,16 @@ async function flushSink(sink, testInfo) {
       });
     }
   }
+  if (testInfo.status === "passed" && process.env.PIWI_CAPTURE_PAGE_INVENTORY === "true") {
+    if (pageReadable) await recordPageWindow(sink, page);
+    const windows = sink.pageInventories.slice(0, MAX_PAGE_INVENTORY_WINDOWS).map((inv) => capPageInventory(inv));
+    if (windows.length > 0) {
+      await testInfo.attach(ATTACHMENT_NAMES.pageInventory, {
+        contentType: "application/json",
+        body: Buffer.from(JSON.stringify(windows))
+      });
+    }
+  }
 }
 var piwiFixtures = {
   // Worker-scoped: patch the shared browser so every page/context created from
@@ -2877,11 +3678,36 @@ var piwiFixtures = {
     async ({}, use, testInfo) => {
       const sink = createSink();
       sink.testInfo = testInfo;
+      if (isProbeMode())
+        sink.probeItem = probeItemForTest({
+          title: testInfo.title,
+          file: testInfo.file,
+          titlePath: testInfo.titlePath
+        });
       currentSink = sink;
       try {
         await use();
       } finally {
         currentSink = null;
+        if (sink.probeItem) {
+          const applied = sink.probeInterception?.applied() ?? false;
+          const level = sink.probeItem.level ?? "client";
+          const handled = level === "server" ? classifyProbeHandled({
+            consoleErrors: sink.consoleEntries.filter((e) => e.type === "error").length,
+            dialogs: sink.dialogs.length,
+            backendError: sink.probeInterception?.serverError() ?? false
+          }) : "n/a";
+          recordProbeOutcome({
+            testCaseId: sink.probeItem.testCaseId,
+            routeKey: sink.probeItem.routeKey,
+            fault: sink.probeItem.fault,
+            applied,
+            outcome: outcomeFromStatus(testInfo.status, applied),
+            level,
+            dependency: sink.probeItem.dependency ?? null,
+            handled
+          });
+        }
         await flushSink(sink, testInfo);
       }
     },