@piwitests/reporter 0.35.0 → 0.38.0

package/dist/index.js

@@ -43,7 +43,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/public/reporter.ts
-var path15 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
@@ -76,8 +76,12 @@ var DEFAULTS = {
   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,
@@ -99,6 +103,7 @@ var PIWI_ENV_KEYS = {
   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",
@@ -109,8 +114,10 @@ var PIWI_ENV_KEYS = {
   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",
@@ -132,6 +139,12 @@ var PIWI_SELECTION_ENV = {
   hash: "PIWI_SELECTION_HASH",
   count: "PIWI_SELECTION_COUNT"
 };
+var PIWI_PROBE_ENV = {
+  flag: "PIWI_PROBE",
+  plan: "PIWI_PROBE_PLAN",
+  results: "PIWI_PROBE_RESULTS",
+  secret: "PIWI_PROBE_SECRET"
+};
 function readBool(val) {
   if (val === void 0) return void 0;
   return val === "true";
@@ -145,6 +158,7 @@ var ENV_FALLBACK_SPECS = [
   { 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" },
@@ -155,8 +169,10 @@ var ENV_FALLBACK_SPECS = [
   { 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" },
@@ -204,12 +220,16 @@ function applyOptionsToEnv(options) {
   if (options.environment) env[PIWI_ENV_KEYS.environment] = options.environment;
   if (options.label) env[PIWI_ENV_KEYS.label] = options.label;
   if (options.runLabel) env[PIWI_ENV_KEYS.runLabel] = options.runLabel;
+  if (options.keep) env[PIWI_ENV_KEYS.keep] = "true";
   if (options.captureLocators === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureLocators] = "false";
   else if (options.captureLocators === true) env[PIWI_ENV_KEYS.captureLocators] = "true";
   if (options.capturePageState === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.capturePageState] = "false";
   else if (options.capturePageState === true) env[PIWI_ENV_KEYS.capturePageState] = "true";
+  if (options.capturePageInventory === false || options.collectPerformanceMetrics === false)
+    env[PIWI_ENV_KEYS.capturePageInventory] = "false";
+  else if (options.capturePageInventory === true) env[PIWI_ENV_KEYS.capturePageInventory] = "true";
   if (options.captureServerTraces === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureServerTraces] = "false";
   else if (options.captureServerTraces === true) env[PIWI_ENV_KEYS.captureServerTraces] = "true";
@@ -398,6 +418,27 @@ var HttpClient = class {
       return {};
     }
   }
+  /** Send a JSON PUT request. Used for the declared-surface manifest upload. */
+  async putJSON(pathname, payload, auth) {
+    const body = JSON.stringify(payload);
+    const res = await this.request("PUT", pathname, {
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      },
+      body,
+      auth
+    });
+    if (res.status < 200 || res.status >= 300) {
+      this.logger.debugError(`Response: ${res.text}`);
+      throw new HttpError(res.status);
+    }
+    try {
+      return JSON.parse(res.text);
+    } catch {
+      return {};
+    }
+  }
   /** Send a multipart form-data POST request. Used for report and trace uploads. */
   async postFormData(pathname, form, auth) {
     const headers = form.getHeaders();
@@ -511,6 +552,7 @@ function toWireTestCase(tc) {
     networkRequests: rest.networkRequests || null,
     webVitals: rest.webVitals || null,
     pageState: rest.pageState || null,
+    pageInventory: rest.pageInventory || null,
     aiUsage: rest.aiUsage || null,
     consoleLogs: rest.consoleLogs || null,
     dialogs: rest.dialogs || null,
@@ -579,6 +621,9 @@ function serializeRun(payload, opts) {
     didNotRunTests: payload.didNotRunTests ?? 0,
     environment: payload.environment ?? null,
     label: payload.label ?? null,
+    keep: payload.keep === true,
+    // A probe run is stamped in `onBegin` (see the reporter), so the marker
+    // already rides in `payload.metadata` here and on every other submit path.
     metadata: payload.metadata,
     instanceId: payload.instanceId,
     playwrightVersion: payload.playwrightVersion,
@@ -950,6 +995,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",
@@ -1152,6 +1198,13 @@ var FileHandler = class {
       } catch {
       }
     }
+    const pageInventory = find(ATTACHMENT_NAMES.pageInventory);
+    if (pageInventory?.body) {
+      try {
+        testCase.pageInventory = JSON.parse(pageInventory.body.toString());
+      } catch {
+      }
+    }
     const aiUsage = find(ATTACHMENT_NAMES.aiUsage);
     if (aiUsage?.body) {
       try {
@@ -1253,7 +1306,7 @@ var MetadataCollector = class {
   }
   /** Collect all available metadata from the environment, config, and suite */
   collect(config, suite, options) {
-    const metadata = {};
+    const metadata = { workingDir: process.cwd() };
     if (options.projectDescription) metadata.projectDescription = options.projectDescription;
     if (options.relatedIssue) metadata.relatedIssue = options.relatedIssue;
     if (options.ciInfo) metadata.ciInfo = options.ciInfo;
@@ -1441,6 +1494,9 @@ var MetadataCollector = class {
         testDir: p.testDir,
         use: {
           browserName: p.use?.browserName || p.name,
+          // The origin of `baseURL` is what the graph treats as the run's own
+          // surface, so only requests to it become route nodes.
+          baseURL: p.use?.baseURL,
           viewport: p.use?.viewport,
           deviceScaleFactor: p.use?.deviceScaleFactor
         }
@@ -1757,6 +1813,7 @@ var StreamManager = class {
               startTime,
               environment: this.options.environment || null,
               label: this.options.label || null,
+              keep: this.options.keep === true,
               metadata,
               instanceId,
               playwrightVersion,
@@ -1779,6 +1836,7 @@ var StreamManager = class {
             startTime,
             environment: this.options.environment || null,
             label: this.options.label || null,
+            keep: this.options.keep === true,
             metadata,
             instanceId,
             playwrightVersion,
@@ -2080,6 +2138,9 @@ function maskTokenLike(text) {
 // ../core/src/step-analysis.ts
 var MAX_STEP_PARAM_KEYS = 20;
 var MAX_STEP_PARAM_VALUE_CHARS = 200;
+function capStepValue(value, max) {
+  return value.length > max ? `${value.slice(0, Math.max(0, max - 1))}\u2026` : value;
+}
 function categorizeStep(title, pwCategory, params) {
   if (!title) return "other";
   if (pwCategory === "hook" || pwCategory === "fixture") return pwCategory;
@@ -2110,11 +2171,11 @@ function normalizeStepParams(raw) {
       out[key] = value;
       count++;
     } else if (typeof value === "string") {
-      out[key] = maskTokenLike(value).slice(0, MAX_STEP_PARAM_VALUE_CHARS);
+      out[key] = capStepValue(maskTokenLike(value), MAX_STEP_PARAM_VALUE_CHARS);
       count++;
     } else if (value != null) {
       try {
-        out[key] = maskTokenLike(JSON.stringify(value)).slice(0, MAX_STEP_PARAM_VALUE_CHARS);
+        out[key] = capStepValue(maskTokenLike(JSON.stringify(value)), MAX_STEP_PARAM_VALUE_CHARS);
         count++;
       } catch {
       }
@@ -2437,8 +2498,8 @@ function isListMode(argv = process.argv) {
 }
 
 // src/public/global-setup.ts
-var path11 = __toESM(require("path"));
-var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
 
 // src/internal/support/aria-sampling.ts
 var path10 = __toESM(require("path"));
@@ -2489,17 +2550,83 @@ function isDueForAriaSample(testInfo) {
   return set.has(ariaSampleIdentity(relativeTestFile(testInfo.file), testInfo.title));
 }
 
+// src/internal/manifest/collect.ts
+var fs12 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var COMMITTED_MANIFEST_FILE = "piwi.manifest.json";
+var INSTRUMENTATION_MANIFEST_PATH = "/__piwi/manifest";
+var INSTRUMENTATION_HEADERS = ["x-piwi-logs", "x-piwi-trace"];
+function parseManifestJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  const routes = Array.isArray(obj.routes) ? obj.routes.filter((r) => !!r && typeof r === "object").filter((r) => typeof r.method === "string" && typeof r.pattern === "string").map((r) => ({
+    method: r.method,
+    pattern: r.pattern,
+    handler: typeof r.handler === "string" ? r.handler : void 0,
+    responses: Array.isArray(r.responses) ? r.responses.filter((c) => Number.isInteger(c)) : void 0
+  })) : void 0;
+  const pages = Array.isArray(obj.pages) ? obj.pages.filter((p) => !!p && typeof p === "object").filter((p) => typeof p.pattern === "string").map((p) => ({ pattern: p.pattern, name: typeof p.name === "string" ? p.name : void 0 })) : void 0;
+  if (!routes && !pages) return null;
+  return { routes, pages };
+}
+function hasInstrumentationHeader(headers) {
+  const get = (name) => typeof headers.get === "function" ? headers.get(name) : headers[name];
+  return INSTRUMENTATION_HEADERS.some((h) => get(h) != null && get(h) !== "");
+}
+function readCommittedManifest(configDir) {
+  const file = path11.join(configDir, COMMITTED_MANIFEST_FILE);
+  try {
+    if (!fs12.existsSync(file)) return null;
+    return parseManifestJson(fs12.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function configDirFromConfig(config) {
+  if (config?.configFile) return path11.dirname(config.configFile);
+  if (config?.rootDir) return config.rootDir;
+  return process.cwd();
+}
+function baseUrlFromConfig(config) {
+  const top = config?.use?.baseURL;
+  if (typeof top === "string" && top) return top;
+  for (const project of config?.projects ?? []) {
+    const url = project?.use?.baseURL;
+    if (typeof url === "string" && url) return url;
+  }
+  return null;
+}
+var INSTRUMENTATION_FETCH_TIMEOUT_MS = 5e3;
+async function fetchInstrumentationManifest(baseUrl, fetchImpl = fetch) {
+  try {
+    const probe = await fetchImpl(baseUrl, { signal: AbortSignal.timeout(INSTRUMENTATION_FETCH_TIMEOUT_MS) });
+    if (!hasInstrumentationHeader(probe.headers)) return null;
+    const manifestUrl = new URL(INSTRUMENTATION_MANIFEST_PATH, baseUrl).toString();
+    const res = await fetchImpl(manifestUrl, { signal: AbortSignal.timeout(INSTRUMENTATION_FETCH_TIMEOUT_MS) });
+    if (!res.ok) return null;
+    return parseManifestJson(await res.text());
+  } catch {
+    return null;
+  }
+}
+
 // src/public/global-setup.ts
 function createGlobalSetup(options, userSetup) {
   return async function globalSetupFn(config) {
-    const piwiReporterPath = path11.resolve(__dirname, "./index.js");
+    const piwiReporterPath = path12.resolve(__dirname, "./index.js");
     let inlineReporterOptions = {};
     if (Array.isArray(config?.reporter)) {
       for (const r of config.reporter) {
         if (!Array.isArray(r) || typeof r[0] !== "string") continue;
         const isPiwi = r[0].toLowerCase().includes("piwi") || (() => {
           try {
-            return path11.resolve(require.resolve(r[0])) === piwiReporterPath;
+            return path12.resolve(require.resolve(r[0])) === piwiReporterPath;
           } catch {
             return false;
           }
@@ -2531,7 +2658,7 @@ function createGlobalSetup(options, userSetup) {
       if (!Array.isArray(r) || typeof r[0] !== "string") return false;
       if (r[0].toLowerCase().includes("piwi")) return true;
       try {
-        return path11.resolve(require.resolve(r[0])) === piwiReporterPath;
+        return path12.resolve(require.resolve(r[0])) === piwiReporterPath;
       } catch {
         return false;
       }
@@ -2555,6 +2682,7 @@ function createGlobalSetup(options, userSetup) {
           projectDescription: opts.projectDescription,
           environment: opts.environment || null,
           label: opts.label || null,
+          keep: opts.keep === true,
           startTime: (/* @__PURE__ */ new Date()).toISOString(),
           instanceId: computeInstanceId(opts.projectName, runLabel),
           shardIndex,
@@ -2563,7 +2691,7 @@ function createGlobalSetup(options, userSetup) {
         auth
       );
       if (response?.runId && response?.setupToken) {
-        fs12.writeFileSync(
+        fs13.writeFileSync(
           getSetupFilePath(opts.projectName),
           JSON.stringify({
             runId: response.runId,
@@ -2574,18 +2702,43 @@ function createGlobalSetup(options, userSetup) {
         logger.debug(`Global setup: initializing run #${response.runId}`);
       }
       if (opts.projectName) clearAriaSampleFile(opts.projectName);
-      if (opts.sampleAriaOnPass !== false && opts.projectName) {
+      const wantsAria = opts.sampleAriaOnPass !== false && !!opts.projectName;
+      const committedManifest = opts.uploadManifest !== false ? readCommittedManifest(configDirFromConfig(config)) : null;
+      const manifestBaseUrl = opts.uploadManifest !== false ? baseUrlFromConfig(config) : null;
+      const wantsManifest = opts.uploadManifest !== false && !!opts.projectName && (!!committedManifest || !!manifestBaseUrl);
+      let projectId;
+      if ((wantsAria || wantsManifest) && opts.projectName) {
         const menu = await httpClient.getJSON("/api/projects/menu", auth);
-        const projectId = menu?.items?.find(
+        projectId = menu?.items?.find(
           (p) => p.name.toLowerCase() === opts.projectName.toLowerCase()
         )?.id;
-        if (projectId != null) {
-          const sampling = await httpClient.getJSON(`/api/projects/${projectId}/aria-sampling`, auth);
-          const tests = Array.isArray(sampling?.tests) ? sampling.tests : null;
-          if (tests) {
-            const identities = tests.filter((t) => typeof t.filePath === "string" && typeof t.title === "string").map((t) => ariaSampleIdentity(t.filePath, t.title));
-            writeAriaSampleFile(opts.projectName, identities);
-            logger.debug(`Green ARIA sampling: ${identities.length} test(s) due a sample.`);
+      }
+      if (wantsAria && projectId != null) {
+        const sampling = await httpClient.getJSON(`/api/projects/${projectId}/aria-sampling`, auth);
+        const tests = Array.isArray(sampling?.tests) ? sampling.tests : null;
+        if (tests) {
+          const identities = tests.filter((t) => typeof t.filePath === "string" && typeof t.title === "string").map((t) => ariaSampleIdentity(t.filePath, t.title));
+          writeAriaSampleFile(opts.projectName, identities);
+          logger.debug(`Green ARIA sampling: ${identities.length} test(s) due a sample.`);
+        }
+      }
+      if (wantsManifest && projectId != null) {
+        const branch = resolveScmBranch(process.env) ?? null;
+        if (committedManifest) {
+          await httpClient.putJSON(
+            `/api/projects/${projectId}/surface/manifest`,
+            { source: "committed", branch, manifest: committedManifest },
+            auth
+          ).catch((e) => logger.debug(`Manifest upload (committed) skipped: ${errorMessage(e)}`));
+        }
+        if (manifestBaseUrl) {
+          const declared = await fetchInstrumentationManifest(manifestBaseUrl);
+          if (declared) {
+            await httpClient.putJSON(
+              `/api/projects/${projectId}/surface/manifest`,
+              { source: "instrumentation", branch, manifest: declared },
+              auth
+            ).catch((e) => logger.debug(`Manifest upload (instrumentation) skipped: ${errorMessage(e)}`));
           }
         }
       }
@@ -2597,8 +2750,110 @@ function createGlobalSetup(options, userSetup) {
 }
 
 // src/public/config-wrapper.ts
-var path12 = __toESM(require("path"));
-var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+
+// src/internal/probe/mode.ts
+var fs14 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+
+// src/internal/probe/plan.ts
+function probeRunMetadata(base = {}) {
+  return { ...base, piwiProbe: true };
+}
+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 path23 = pattern.split("?")[0] ?? pattern;
+  const escaped = path23.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 path23;
+  try {
+    path23 = new URL(url).pathname;
+  } catch {
+    path23 = url.split("?")[0] ?? url;
+  }
+  return patternToRegex(pattern).test(path23);
+}
+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 path23 = process.env[PIWI_PROBE_ENV.plan];
+  if (path23) {
+    try {
+      planCache = JSON.parse(fs14.readFileSync(path23, "utf8"));
+    } catch {
+      planCache = null;
+    }
+  }
+  return planCache;
+}
+function probeItemForTest(test) {
+  const plan = loadPlan();
+  if (!plan) return null;
+  const filePath = test.file ? path13.relative(process.cwd(), test.file).split(path13.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 path23 = process.env[PIWI_PROBE_ENV.results];
+  if (!path23) return;
+  try {
+    fs14.appendFileSync(path23, `${JSON.stringify(line)}
+`);
+  } catch {
+  }
+}
+
+// src/public/config-wrapper.ts
 var PIWI_MODULE = "@piwitests/reporter";
 var CAPTURE_DEFAULTS = {
   screenshot: "only-on-failure",
@@ -2663,11 +2918,11 @@ function injectReporter(reporter, piwiOptions) {
 }
 function resolveSetupModule() {
   const candidates = [
-    path12.join(__dirname, "global-setup-module.js"),
-    path12.join(__dirname, "..", "global-setup-module.js"),
-    path12.join(__dirname, "..", "global-setup-module.ts")
+    path14.join(__dirname, "global-setup-module.js"),
+    path14.join(__dirname, "..", "global-setup-module.js"),
+    path14.join(__dirname, "..", "global-setup-module.ts")
   ];
-  return candidates.find((candidate) => fs13.existsSync(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => fs15.existsSync(candidate)) ?? candidates[0];
 }
 function wrapConfig(config, piwiOptions) {
   if (piwiOptions) applyOptionsToEnv(piwiOptions);
@@ -2679,6 +2934,7 @@ function wrapConfig(config, piwiOptions) {
   const forwarded = {};
   const failOnFlaky = piwiOptions?.failOnFlakyTests ?? readBool(process.env[PIWI_ENV_KEYS.failOnFlakyTests]);
   if (failOnFlaky === true) forwarded.failOnFlakyTests = true;
+  if (isProbeMode()) forwarded.retries = 0;
   const use = applyCaptureDefaults(config.use, piwiOptions);
   return {
     ...config,
@@ -2867,7 +3123,7 @@ function collectTestMetadata(annotations) {
 }
 
 // src/internal/collect/error-text.ts
-var path13 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 
 // ../core/src/error-text.ts
 function joinErrorMessages(errors) {
@@ -2896,13 +3152,13 @@ function buildErrorText(result) {
   if (!text) return null;
   const loc = result.error?.location;
   if (!loc?.file) return text;
-  const rel = path13.relative(process.cwd(), loc.file).split(path13.sep).join("/");
+  const rel = path15.relative(process.cwd(), loc.file).split(path15.sep).join("/");
   return appendErrorLocation(text, { file: rel, line: loc.line, column: loc.column });
 }
 
 // src/internal/support/ci-output.ts
-var fs14 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var SUMMARY_MAX_FAILURES = 20;
 function emitRunOutputs(output, logger, outputFile, env = process.env) {
   logger.info(`View run: ${output.runUrl}`);
@@ -2912,9 +3168,9 @@ function emitRunOutputs(output, logger, outputFile, env = process.env) {
 }
 function writeOutputFile(file, output, logger) {
   try {
-    const dir = path14.dirname(file);
-    if (dir && dir !== ".") fs14.mkdirSync(dir, { recursive: true });
-    fs14.writeFileSync(
+    const dir = path16.dirname(file);
+    if (dir && dir !== ".") fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(
       file,
       JSON.stringify(
         {
@@ -2994,7 +3250,7 @@ function emitGitLabDotenv(output, env, logger) {
   if (output.projectId != null) lines.push(`PIWI_PROJECT_ID=${output.projectId}`);
   if (output.ciBuildUrl) lines.push(`PIWI_CI_BUILD_URL=${output.ciBuildUrl}`);
   try {
-    fs14.writeFileSync(file, lines.join("\n") + "\n");
+    fs16.writeFileSync(file, lines.join("\n") + "\n");
     logger.info(`Wrote GitLab dotenv report to ${file} (declare it as artifacts:reports:dotenv)`);
   } catch (error) {
     logger.warn(`Failed to write GitLab dotenv file '${file}': ${errorMessage(error)}`);
@@ -3002,7 +3258,7 @@ function emitGitLabDotenv(output, env, logger) {
 }
 function appendFileLines(file, lines, logger, label) {
   try {
-    fs14.appendFileSync(file, lines.join("\n") + "\n");
+    fs16.appendFileSync(file, lines.join("\n") + "\n");
   } catch (error) {
     logger.warn(`Failed to write GitHub Actions ${label}: ${errorMessage(error)}`);
   }
@@ -3121,6 +3377,7 @@ var RunSubmitter = class {
       didNotRunTests: run.didNotRunTests,
       environment: run.options.environment,
       label: run.options.label || null,
+      keep: run.options.keep === true,
       metadata: run.metadata,
       instanceId: run.instanceId,
       playwrightVersion: run.playwrightVersion ?? void 0,
@@ -3151,6 +3408,7 @@ var RunSubmitter = class {
         flakyTests,
         durations,
         label: run.options.label || null,
+        keep: run.options.keep === true,
         metadata: run.metadata,
         hasPendingUploads: this.hasReports(run),
         playwrightVersion: run.playwrightVersion ?? void 0,
@@ -3238,6 +3496,298 @@ var RunSubmitter = class {
   }
 };
 
+// ../core/src/locator-chain.ts
+var LOCATING_METHODS = /* @__PURE__ */ new Set([
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator",
+  "frameLocator"
+]);
+var NARROWING_METHODS = /* @__PURE__ */ new Set([
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "visible",
+  "contentFrame",
+  "owner"
+]);
+var LOCATOR_CHAIN_METHODS = /* @__PURE__ */ new Set([...LOCATING_METHODS, ...NARROWING_METHODS]);
+var LocatorParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LocatorParseError";
+  }
+};
+var SIMPLE_ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0"
+};
+var Parser = class {
+  constructor(src) {
+    this.src = src;
+    this.i = 0;
+  }
+  parseTopLevel() {
+    const chain = this.parseChain();
+    this.skipSpace();
+    if (this.i < this.src.length) this.fail("unexpected text");
+    return chain;
+  }
+  fail(message) {
+    throw new LocatorParseError(`${message} at "${this.src.slice(this.i, this.i + 20)}"`);
+  }
+  skipSpace() {
+    while (this.i < this.src.length && /\s/.test(this.src[this.i])) this.i++;
+  }
+  peek() {
+    return this.src[this.i];
+  }
+  expect(ch) {
+    this.skipSpace();
+    if (this.src[this.i] !== ch) this.fail(`expected "${ch}"`);
+    this.i++;
+  }
+  identifier() {
+    const m = /^[A-Za-z_$][\w$]*/.exec(this.src.slice(this.i));
+    if (!m) this.fail("expected a name");
+    this.i += m[0].length;
+    return m[0];
+  }
+  /**
+   * A chain of calls joined by `.`. With `lenient`, parsing stops before the
+   * first link that doesn't parse instead of failing, so a chain followed by
+   * other text (an error message) is read up to where it ends. `spans` receives
+   * where each top-level call starts and ends.
+   */
+  parseChain(opts = {}) {
+    this.skipSpace();
+    const calls = [];
+    for (; ; ) {
+      const before = this.i;
+      if (calls.length > 0) this.i++;
+      this.skipSpace();
+      const start = this.i;
+      try {
+        calls.push(this.parseCall(calls.length === 0));
+      } catch (error) {
+        if (!opts.lenient || calls.length === 0) throw error;
+        this.i = before;
+        break;
+      }
+      opts.spans?.push({ start, end: this.i });
+      const end = this.i;
+      this.skipSpace();
+      if (this.peek() !== ".") {
+        this.i = end;
+        break;
+      }
+    }
+    return { calls };
+  }
+  /** Where the parser stopped. */
+  get position() {
+    return this.i;
+  }
+  parseCall(first) {
+    this.skipSpace();
+    const method = this.identifier();
+    if (!LOCATOR_CHAIN_METHODS.has(method)) this.fail(`unsupported method ${method}()`);
+    if (first && !LOCATING_METHODS.has(method)) this.fail(`${method}() needs a locator before it`);
+    this.expect("(");
+    const args = [];
+    this.skipSpace();
+    if (this.peek() === ")") {
+      this.i++;
+      return { method, args };
+    }
+    for (; ; ) {
+      args.push(this.parseValue());
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        this.skipSpace();
+        if (this.peek() === ")") {
+          this.i++;
+          break;
+        }
+        continue;
+      }
+      this.expect(")");
+      break;
+    }
+    return { method, args };
+  }
+  parseValue() {
+    this.skipSpace();
+    const ch = this.peek();
+    if (ch === "'" || ch === '"' || ch === "`") return { type: "string", value: this.parseString() };
+    if (ch === "/") return this.parseRegex();
+    if (ch === "{") return this.parseObject();
+    if (ch !== void 0 && /[-\d]/.test(ch)) {
+      const m = /^-?\d+(?:\.\d+)?/.exec(this.src.slice(this.i));
+      if (!m) this.fail("expected a number");
+      this.i += m[0].length;
+      return { type: "number", value: Number(m[0]) };
+    }
+    const rest = this.src.slice(this.i);
+    if (/^true\b/.test(rest)) {
+      this.i += 4;
+      return { type: "boolean", value: true };
+    }
+    if (/^false\b/.test(rest)) {
+      this.i += 5;
+      return { type: "boolean", value: false };
+    }
+    if (/^[A-Za-z_$]/.test(rest)) return { type: "chain", chain: this.parseChain() };
+    return this.fail("expected a value");
+  }
+  /** A quoted string, decoding the escapes `JSON.stringify` and JavaScript produce. */
+  parseString() {
+    const quote = this.src[this.i];
+    let out = "";
+    this.i++;
+    while (this.i < this.src.length) {
+      const c = this.src[this.i];
+      if (c === quote) {
+        this.i++;
+        return out;
+      }
+      if (c !== "\\") {
+        out += c;
+        this.i++;
+        continue;
+      }
+      const next = this.src[this.i + 1];
+      if (next === void 0) break;
+      const simple = SIMPLE_ESCAPES[next];
+      if (simple !== void 0) {
+        out += simple;
+        this.i += 2;
+        continue;
+      }
+      const hex = next === "u" && this.src[this.i + 2] === "{" ? /^u\{([0-9a-fA-F]{1,6})\}/.exec(this.src.slice(this.i + 1)) : next === "u" ? /^u([0-9a-fA-F]{4})/.exec(this.src.slice(this.i + 1)) : next === "x" ? /^x([0-9a-fA-F]{2})/.exec(this.src.slice(this.i + 1)) : null;
+      if (hex) {
+        out += String.fromCodePoint(parseInt(hex[1], 16));
+        this.i += 1 + hex[0].length;
+        continue;
+      }
+      if (next === "u" || next === "x") this.fail("malformed escape");
+      out += next;
+      this.i += 2;
+    }
+    return this.fail("unterminated string");
+  }
+  parseRegex() {
+    let j = this.i + 1;
+    let inClass = false;
+    while (j < this.src.length) {
+      const c = this.src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "[") inClass = true;
+      else if (c === "]") inClass = false;
+      else if (c === "/" && !inClass) break;
+      j++;
+    }
+    if (j >= this.src.length) this.fail("unterminated regex");
+    const source = this.src.slice(this.i + 1, j);
+    const flags = /^[a-z]*/.exec(this.src.slice(j + 1))[0];
+    this.i = j + 1 + flags.length;
+    return { type: "regex", source, flags };
+  }
+  parseObject() {
+    this.expect("{");
+    const entries = [];
+    for (; ; ) {
+      this.skipSpace();
+      if (this.peek() === "}") {
+        this.i++;
+        break;
+      }
+      const ch = this.peek();
+      const key = ch === "'" || ch === '"' ? this.parseString() : this.identifier();
+      this.expect(":");
+      entries.push([key, this.parseValue()]);
+      this.skipSpace();
+      if (this.peek() === ",") {
+        this.i++;
+        continue;
+      }
+      this.expect("}");
+      break;
+    }
+    return { type: "object", entries };
+  }
+};
+function parseLocatorChain(expr) {
+  const trimmed = expr.trim().replace(/^(?:await\s+)?(?:this\.)?page\./, "");
+  if (!trimmed) throw new LocatorParseError("empty expression");
+  return new Parser(trimmed).parseTopLevel();
+}
+function scanLocatorChain(text) {
+  const parser = new Parser(text);
+  const spans = [];
+  try {
+    const chain = parser.parseChain({ lenient: true, spans });
+    return { chain, spans, end: parser.position };
+  } catch {
+    return null;
+  }
+}
+function tryParseLocatorChain(expr) {
+  try {
+    return parseLocatorChain(expr);
+  } catch {
+    return null;
+  }
+}
+function parseLeafLocatorCall(expr) {
+  const chain = tryParseLocatorChain(expr);
+  if (!chain) return null;
+  for (let i = chain.calls.length - 1; i >= 0; i--) {
+    if (LOCATING_METHODS.has(chain.calls[i].method)) return chain.calls[i];
+  }
+  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);
+}
+
 // ../core/src/locator-methods.ts
 var LOCATOR_BUILDER_METHODS = [
   "getByRole",
@@ -3282,10 +3832,35 @@ function extractLeafSelector(text) {
   if (!first) return null;
   const nl = text.indexOf("\n", first.index);
   const region = text.slice(first.index, nl === -1 ? void 0 : nl);
+  const scanned = readChain(region);
+  if (scanned) {
+    for (let k = scanned.chain.calls.length - 1; k >= 0; k--) {
+      if (LEAF_METHODS.has(scanned.chain.calls[k].method)) {
+        return region.slice(scanned.spans[k].start, scanned.spans[k].end);
+      }
+    }
+    return null;
+  }
+  return lenientLeaf(region);
+}
+var LEAF_METHODS = new Set(LOCATOR_BUILDER_METHODS);
+function skipQuoted(text, i) {
+  const quote = text[i];
+  for (let j = i + 1; j < text.length; j++) {
+    if (text[j] === "\\") j++;
+    else if (text[j] === quote) return j + 1;
+  }
+  return text.length;
+}
+function lenientLeaf(region) {
   let depth = 0;
   let leafStart = -1;
   for (let i = 0; i < region.length; i++) {
     const ch = region[i];
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(region, i) - 1;
+      continue;
+    }
     if (ch === "(") {
       depth++;
       continue;
@@ -3308,7 +3883,9 @@ function extractLeafSelector(text) {
   depth = 0;
   for (let i = leafStart; i < region.length; i++) {
     const ch = region[i];
-    if (ch === "(") {
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(region, i) - 1;
+    } else if (ch === "(") {
       depth++;
     } else if (ch === ")") {
       depth--;
@@ -3322,11 +3899,15 @@ function extractLocatorChain(text) {
   if (!first) return null;
   const nl = text.indexOf("\n", first.index);
   const region = text.slice(first.index, nl === -1 ? void 0 : nl);
+  const scanned = readChain(region);
+  if (scanned) return region.slice(0, scanned.end);
   let depth = 0;
   let end = -1;
   for (let i = 0; i < region.length; i++) {
     const ch = region[i];
-    if (ch === "(") {
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(region, i) - 1;
+    } else if (ch === "(") {
       depth++;
     } else if (ch === ")") {
       if (depth > 0) depth--;
@@ -3341,6 +3922,12 @@ function extractLocatorChain(text) {
   if (end === -1) return region.slice(0, 80);
   return region.slice(0, end);
 }
+function readChain(region) {
+  const scanned = scanLocatorChain(region);
+  if (!scanned) return null;
+  const link = /^\s*\.\s*(\w+)\(/.exec(region.slice(scanned.end));
+  return link && CHAIN_LINK_METHODS.has(link[1]) ? null : scanned;
+}
 function extractTopFrame(text) {
   const frameRe = /^\s+at (?:.*? \()?([^()\s][^()]*?):(\d+):(\d+)\)?\s*$/gm;
   let m;
@@ -4064,7 +4651,7 @@ function testLocation(test) {
   return `${testFile(test)}:${test.location.line}:${test.location.column}`;
 }
 function testFile(test) {
-  return path15.relative(process.cwd(), test.location.file).split(path15.sep).join("/");
+  return path17.relative(process.cwd(), test.location.file).split(path17.sep).join("/");
 }
 var PiwiDashboardReporter = class _PiwiDashboardReporter {
   constructor(rawOptions = {}) {
@@ -4181,6 +4768,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       );
     }
     this.metadata = this.metadataCollector.collect(config, suite, this.options);
+    if (isProbeMode()) this.metadata = probeRunMetadata(this.metadata);
     this.plannedTests = suite.allTests();
     const pwShard = config.shard;
     if (pwShard?.total && pwShard.total > 1) {
@@ -4219,18 +4807,27 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     }
   }
   static {
-    /**
-     * Step categories streamed live while the run executes. `pw:assert` is
-     * excluded: it is the polling noise of `expect()`, not a step a human
-     * watches; the meaningful readout is the `pw:expect` wrapper around it.
-     */
-    this.LIVE_STEP_CATEGORIES = /* @__PURE__ */ new Set(["hook", "fixture", "pw:api", "pw:expect"]);
+    /** Step categories streamed live while the run executes. */
+    this.LIVE_STEP_CATEGORIES = /* @__PURE__ */ new Set(["hook", "fixture", "pw:api", "expect"]);
+  }
+  /**
+   * Whether a step streams live: its category is in `LIVE_STEP_CATEGORIES`
+   * and no ancestor is an `expect` step. The steps inside an assertion are its
+   * polling — every `expect.poll` attempt and `toPass` retry — not a step a
+   * human watches; the meaningful readout is the assertion around them.
+   */
+  static isLiveStep(step) {
+    if (!_PiwiDashboardReporter.LIVE_STEP_CATEGORIES.has(step.category)) return false;
+    for (let parent = step.parent; parent; parent = parent.parent) {
+      if (parent.category === "expect") return false;
+    }
+    return true;
   }
   /** Playwright reporter hook: called when a step (including hook/fixture) begins */
   onStepBegin(test, _result, step) {
     if (!this.enabled || !this.streamManager) return;
+    if (!_PiwiDashboardReporter.isLiveStep(step)) return;
     const cat = step.category;
-    if (!_PiwiDashboardReporter.LIVE_STEP_CATEGORIES.has(cat)) return;
     const event = {
       type: "step-begin",
       title: step.title,
@@ -4246,8 +4843,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   /** Playwright reporter hook: called when a step (including hook/fixture) ends */
   onStepEnd(test, _result, step) {
     if (!this.enabled || !this.streamManager) return;
+    if (!_PiwiDashboardReporter.isLiveStep(step)) return;
     const cat = step.category;
-    if (!_PiwiDashboardReporter.LIVE_STEP_CATEGORIES.has(cat)) return;
     const workerIndex = workerIndexOf(_result);
     const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : null;
     const event = {
@@ -4537,7 +5134,7 @@ async function resolveSelection(options = {}) {
 }
 
 // src/internal/capture/capture-fixtures.ts
-var import_node_zlib = require("zlib");
+var import_node_zlib2 = require("zlib");
 
 // ../picker-dom/src/probe.ts
 function probeElementAttrs(el, arg) {
@@ -5895,7 +6492,7 @@ function mergeCandidates(base, extra) {
 }
 
 // src/internal/capture/locator-healing.ts
-var path16 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 
 // ../core/src/locator-fingerprint.ts
 var ELEMENT_MATCH_SCORES = { role: 60, text: 55, label: 50 };
@@ -6265,16 +6862,318 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
     }
     let rel = file;
     try {
-      rel = path16.relative(process.cwd(), file);
+      rel = path18.relative(process.cwd(), file);
     } catch {
     }
-    rel = rel.split(path16.sep).join("/");
+    rel = rel.split(path18.sep).join("/");
     if (rel.startsWith("./")) rel = rel.slice(2);
     return `${rel}:${m[3]}:${m[4]}`;
   }
   return null;
 }
 
+// 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/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((resolve5) => setTimeout(resolve5, 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";
@@ -6311,88 +7210,11 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path17 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var ANSI_RE2 = /\[[0-9;]*m/g;
-function endOfString(s, start) {
-  const q = s[start];
-  for (let i = start + 1; i < s.length; i++) {
-    if (s[i] === "\\") {
-      i++;
-      continue;
-    }
-    if (s[i] === q) return i;
-  }
-  return s.length - 1;
-}
-function matchBrace(s, start) {
-  let depth = 0;
-  for (let i = start; i < s.length; i++) {
-    if (s[i] === "{") depth++;
-    else if (s[i] === "}" && --depth === 0) return i;
-  }
-  return s.length - 1;
-}
-function parseOptions(src) {
-  const obj = {};
-  const re = /(\w+)\s*:\s*('(?:\\.|[^'])*'|"(?:\\.|[^"])*"|true|false|-?\d+)/g;
-  let m;
-  while ((m = re.exec(src)) !== null) {
-    const key = m[1];
-    const raw = m[2];
-    if (raw === "true") obj[key] = true;
-    else if (raw === "false") obj[key] = false;
-    else if (/^-?\d+$/.test(raw)) obj[key] = Number(raw);
-    else obj[key] = raw.slice(1, -1).replace(/\\(.)/g, "$1");
-  }
-  return obj;
-}
-function parseArgs(inner) {
-  const args = [];
-  let i = 0;
-  while (i < inner.length) {
-    const c = inner[i];
-    if (c === " " || c === ",") {
-      i++;
-      continue;
-    }
-    if (c === "'" || c === '"') {
-      const end = endOfString(inner, i);
-      args.push(inner.slice(i + 1, end).replace(/\\(.)/g, "$1"));
-      i = end + 1;
-      continue;
-    }
-    if (c === "{") {
-      const end = matchBrace(inner, i);
-      args.push(parseOptions(inner.slice(i, end + 1)));
-      i = end + 1;
-      continue;
-    }
-    i++;
-  }
-  return args;
-}
-function leafExpression(expr) {
-  let depth = 0;
-  let leafStart = 0;
-  for (let i = 0; i < expr.length - 1; i++) {
-    const c = expr[i];
-    if (c === "'" || c === '"') {
-      i = endOfString(expr, i);
-      continue;
-    }
-    if (c === "(") depth++;
-    else if (c === ")") {
-      depth--;
-      if (depth === 0 && expr[i + 1] === ".") leafStart = i + 2;
-    }
-  }
-  return expr.slice(leafStart);
-}
 function parseLeafLocatorExpression(rawExpr) {
-  const expr = leafExpression(rawExpr.trim());
-  const m = /^([A-Za-z]+)\((.*)\)$/s.exec(expr);
-  if (!m) return null;
-  return { method: m[1], args: parseArgs(m[2].trim()) };
+  const leaf = parseLeafLocatorCall(rawExpr);
+  return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
 }
 function deriveFailedLocator(testInfo) {
   const info = testInfo;
@@ -6405,7 +7227,7 @@ ${err.stack ?? ""}`.replace(ANSI_RE2, "");
     const parsed = parseLeafLocatorExpression(line[1].trim());
     if (!parsed) continue;
     const loc = err.location;
-    const location = loc ? `${path17.relative(process.cwd(), loc.file).split(path17.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path19.relative(process.cwd(), loc.file).split(path19.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed.method, args: parsed.args, location };
   }
   return null;
@@ -6599,6 +7421,9 @@ function createSink() {
     stashedPageState: null,
     stashedAria: null,
     stashedAriaJson: null,
+    pageInventories: [],
+    probeItem: null,
+    probeInterception: null,
     pickOffered: false,
     userPick: null
   };
@@ -6775,6 +7600,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((resolve5, reject) => {
+    const timer = setTimeout(() => reject(new Error("page inventory read timed out")), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve5(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;
@@ -6799,6 +7680,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;
@@ -7042,6 +7926,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") {
@@ -7077,6 +7968,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;
@@ -7136,14 +8035,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 {
             }
           }
@@ -7328,6 +8227,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
@@ -7353,11 +8262,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);
       }
     },
@@ -7369,13 +8303,13 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs16 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs15 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
 var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET2 = new Set(ACTION_METHODS);
@@ -7468,7 +8402,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs15.readFileSync(file, "utf8");
+    text = fs17.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -7478,28 +8412,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs15.existsSync(file) && fs15.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs15.mkdirSync(path18.dirname(file), { recursive: true });
+    if (fs17.existsSync(file) && fs17.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs17.mkdirSync(path20.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs15.writeFileSync(tmp, canonical);
-    fs15.renameSync(tmp, file);
+    fs17.writeFileSync(tmp, canonical);
+    fs17.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs15.mkdirSync(path18.dirname(file), { recursive: true });
+  fs17.mkdirSync(path20.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs15.openSync(lock, "wx");
-      fs15.closeSync(fd);
+      const fd = fs17.openSync(lock, "wx");
+      fs17.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs15.unlinkSync(lock);
+          fs17.unlinkSync(lock);
         } catch {
         }
       }
@@ -7509,7 +8443,7 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs15.unlinkSync(lock);
+      fs17.unlinkSync(lock);
     } catch {
     }
   }
@@ -7517,7 +8451,7 @@ function withEntryLock(file, fn) {
 
 // src/internal/ai/keys.ts
 var crypto3 = __toESM(require("crypto"));
-var path19 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
   return template.trim().replace(/\s+/g, " ").toLowerCase();
@@ -7531,13 +8465,13 @@ function slug(text, maxLength = 40) {
   return (base || "x").slice(0, maxLength).replace(/-+$/g, "") || "x";
 }
 function entryDir(specFile, dir = DEFAULT_AI_DIR) {
-  return path19.join(path19.dirname(specFile), dir, path19.basename(specFile));
+  return path21.join(path21.dirname(specFile), dir, path21.basename(specFile));
 }
 function entryPath(params) {
   const basis = `${normalizeTemplate(params.testTitle)}::${normalizeTemplate(params.template)}`;
   const hash = hashTemplate(basis, params.ordinal ?? 0);
   const name = `${slug(params.testTitle)}.${slug(params.template)}.${hash}.json`;
-  return path19.join(entryDir(params.specFile, params.dir), name);
+  return path21.join(entryDir(params.specFile, params.dir), name);
 }
 function parseLocation(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
@@ -7991,7 +8925,7 @@ function testIdentity(testInfo) {
   return titles.length > 0 ? titles.join(" \u203A ") : testInfo.title;
 }
 function relativeToCwd(file) {
-  return path20.relative(process.cwd(), file).split(path20.sep).join("/");
+  return path22.relative(process.cwd(), file).split(path22.sep).join("/");
 }
 function recordIntents(intents, entry) {
   const add = (locator, kind) => {
@@ -8018,7 +8952,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs16.readFileSync(testInfo.file, "utf8");
+        source = fs18.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }