@piwitests/reporter 0.26.1 → 0.28.0

package/dist/index.js

@@ -43,7 +43,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/public/reporter.ts
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 
 // src/internal/config/desktop.ts
 var fs = __toESM(require("fs"));
@@ -77,9 +77,12 @@ var DEFAULTS = {
   captureLocators: true,
   capturePageState: true,
   captureServerTraces: true,
+  sampleAriaOnPass: true,
+  defaultCapture: true,
   streaming: true,
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
   failOnFlakyTests: false,
   username: null,
   password: null,
@@ -99,6 +102,7 @@ var PIWI_ENV_KEYS = {
   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",
@@ -106,6 +110,8 @@ var PIWI_ENV_KEYS = {
   captureLocators: "PIWI_CAPTURE_LOCATORS",
   capturePageState: "PIWI_CAPTURE_PAGE_STATE",
   captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
+  defaultCapture: "PIWI_DEFAULT_CAPTURE",
   inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
   pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
   outputFile: "PIWI_OUTPUT_FILE",
@@ -119,6 +125,7 @@ var PIWI_ENV_KEYS = {
   aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
 };
 var PIWI_DESKTOP_CONFIG_ENV = "PIWI_DESKTOP_CONFIG";
+var PIWI_DEFAULTED_CAPTURE_ENV = "PIWI_DEFAULTED_CAPTURE";
 var PIWI_SELECTION_ENV = {
   key: "PIWI_SELECTION",
   version: "PIWI_SELECTION_VERSION",
@@ -141,6 +148,7 @@ var ENV_FALLBACK_SPECS = [
   { 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" },
@@ -148,6 +156,8 @@ var ENV_FALLBACK_SPECS = [
   { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
   { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
   { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, 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" }
@@ -203,6 +213,8 @@ function applyOptionsToEnv(options) {
   if (options.captureServerTraces === false || options.collectPerformanceMetrics === false)
     env[PIWI_ENV_KEYS.captureServerTraces] = "false";
   else if (options.captureServerTraces === true) env[PIWI_ENV_KEYS.captureServerTraces] = "true";
+  if (options.sampleAriaOnPass === false) env[PIWI_ENV_KEYS.sampleAriaOnPass] = "false";
+  else if (options.sampleAriaOnPass === true) env[PIWI_ENV_KEYS.sampleAriaOnPass] = "true";
   if (options.inspectOnFailure !== void 0) env[PIWI_ENV_KEYS.inspectOnFailure] = String(options.inspectOnFailure);
   if (options.pickLocatorOnFailure !== void 0)
     env[PIWI_ENV_KEYS.pickLocatorOnFailure] = String(options.pickLocatorOnFailure);
@@ -342,6 +354,29 @@ var HttpClient = class {
     this.logger.debug("Logged in successfully");
     return cookie;
   }
+  /**
+   * Send a JSON GET request, returning the parsed body, or `null` on any non-2xx
+   * status or parse failure. Unlike `postJSON` this never throws — its callers
+   * treat a missing or unreachable endpoint as "feature unavailable".
+   */
+  async getJSON(pathname, auth) {
+    let res;
+    try {
+      res = await this.request("GET", pathname, { auth });
+    } catch (error) {
+      this.logger.debug(`GET ${pathname} failed: ${error.message}`);
+      return null;
+    }
+    if (res.status < 200 || res.status >= 300) {
+      this.logger.debug(`GET ${pathname} returned ${res.status}`);
+      return null;
+    }
+    try {
+      return JSON.parse(res.text);
+    } catch {
+      return null;
+    }
+  }
   /** Send a JSON POST request. `auth` can be an API key (prefix `pd_`) or a session cookie string. */
   async postJSON(pathname, payload, auth) {
     const body = JSON.stringify(payload);
@@ -392,7 +427,7 @@ var HttpClient = class {
         {
           hostname: url.hostname,
           port: url.port || (url.protocol === "https:" ? 443 : 80),
-          path: url.pathname,
+          path: url.pathname + url.search,
           method,
           headers
         },
@@ -404,6 +439,12 @@ var HttpClient = class {
           res.on("end", () => {
             resolve5({ status: res.statusCode ?? 0, text: data, headers: res.headers });
           });
+          res.on("error", reject);
+          res.on("close", () => {
+            if (!res.complete) {
+              reject(new Error(`Connection to ${pathname} closed before the response completed`));
+            }
+          });
         }
       );
       req.on("error", reject);
@@ -472,7 +513,9 @@ function toWireTestCase(tc) {
     pageState: rest.pageState || null,
     aiUsage: rest.aiUsage || null,
     consoleLogs: rest.consoleLogs || null,
+    dialogs: rest.dialogs || null,
     ariaSnapshot: rest.ariaSnapshot || null,
+    ariaSnapshotJson: rest.ariaSnapshotJson || null,
     testSource: rest.testSource || null,
     testSourceFrames: rest.testSourceFrames || null,
     browser: rest.browser || null,
@@ -480,6 +523,7 @@ function toWireTestCase(tc) {
     suiteConfig: rest.suiteConfig ?? null,
     testAnnotations: rest.testAnnotations ?? null,
     tags: rest.tags ?? null,
+    locks: rest.locks ?? null,
     testMeta: rest.testMeta ?? null,
     locatorSnapshots: rest.locatorSnapshots || null,
     didNotRunReason: rest.didNotRunReason ?? null,
@@ -831,6 +875,7 @@ var CrashRecovery = class {
 
 // src/internal/files/file-handler.ts
 var fs6 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
 var path6 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
 
@@ -867,7 +912,9 @@ async function compressDirectory(sourceDir) {
 var ATTACHMENT_NAMES = {
   locators: "piwi-locators",
   ariaSnapshot: "piwi-aria-snapshot",
+  ariaSnapshotJson: "piwi-aria-snapshot-json",
   console: "piwi-console",
+  dialogs: "piwi-dialogs",
   network: "piwi-network",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",
@@ -881,9 +928,30 @@ var LOCATOR_SUGGESTION_ANNOTATION = ATTACHMENT_NAMES.locatorSuggestion;
 var USER_PICK_ANNOTATION = ATTACHMENT_NAMES.userPick;
 
 // src/internal/files/file-handler.ts
+var MAX_ATTACHMENT_BYTES = 500 * 1024 * 1024;
+var BODY_EXTENSIONS = {
+  "application/json": ".json",
+  "application/pdf": ".pdf",
+  "application/zip": ".zip",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/svg+xml": ".svg",
+  "image/webp": ".webp",
+  "text/csv": ".csv",
+  "text/html": ".html",
+  "text/markdown": ".md",
+  "text/plain": ".txt"
+};
 var FileHandler = class {
-  constructor(logger = new Logger()) {
+  constructor(logger = new Logger(), maxAttachmentBytes = MAX_ATTACHMENT_BYTES) {
     this.logger = logger;
+    this.maxAttachmentBytes = maxAttachmentBytes;
+    /** Temp files written for body-only attachments, keyed by attachment so repeated lookups reuse one file. */
+    this.bodyFiles = /* @__PURE__ */ new WeakMap();
+    this.bodyDir = null;
+    this.bodyFileCount = 0;
+    /** Attachments already reported as oversized, so each one warns once per run. */
+    this.oversizedWarned = /* @__PURE__ */ new Set();
   }
   /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
   findHTMLReportDirectory(customDir) {
@@ -922,25 +990,83 @@ var FileHandler = class {
     }
     return Array.from(set);
   }
-  /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-*` attachments. */
+  /**
+   * Return all non-trace, non-internal attachments from a test case as files
+   * on disk. Skips `trace` and `piwi-*` attachments. A body-only attachment
+   * (`testInfo.attach(name, { body })`) is written to a temp file under
+   * `os.tmpdir()` once and reused by later calls; anything above
+   * `maxAttachmentBytes` is skipped with a single warning.
+   */
   findAllAttachments(testCase) {
     const result = [];
     if (testCase.attachments) {
       for (const a of testCase.attachments) {
         if (a.name === "trace") continue;
         if (a.name && INTERNAL_ATTACHMENT_NAMES.has(a.name)) continue;
-        if (a.path && fs6.existsSync(a.path)) {
-          result.push({
-            name: a.name || "attachment",
-            path: path6.resolve(a.path),
-            contentType: a.contentType || "application/octet-stream",
-            originalName: path6.basename(a.path)
-          });
-        }
+        const resolved = a.path ? this.resolvePathAttachment(a, testCase) : this.resolveBodyAttachment(a, testCase);
+        if (resolved) result.push(resolved);
       }
     }
     return result;
   }
+  /** Delete the temp files written for body-only attachments. Call once the run's uploads are done. */
+  cleanupBodyAttachments() {
+    if (!this.bodyDir) return;
+    try {
+      fs6.rmSync(this.bodyDir, { recursive: true, force: true });
+    } catch (error) {
+      this.logger.debug(`Could not remove temp attachments at ${this.bodyDir}: ${errorMessage(error)}`);
+    }
+    this.bodyDir = null;
+  }
+  resolvePathAttachment(a, testCase) {
+    if (!a.path || !fs6.existsSync(a.path)) return null;
+    const size = fs6.statSync(a.path).size;
+    if (size > this.maxAttachmentBytes) {
+      this.warnOversized(a, testCase, size);
+      return null;
+    }
+    return {
+      name: a.name || "attachment",
+      path: path6.resolve(a.path),
+      contentType: a.contentType || "application/octet-stream",
+      originalName: path6.basename(a.path)
+    };
+  }
+  resolveBodyAttachment(a, testCase) {
+    if (!a.body) return null;
+    const body = Buffer.isBuffer(a.body) ? a.body : Buffer.from(a.body);
+    if (body.length > this.maxAttachmentBytes) {
+      this.warnOversized(a, testCase, body.length);
+      return null;
+    }
+    const contentType = a.contentType || "application/octet-stream";
+    const originalName = `${safeFileName(a.name || "attachment")}${BODY_EXTENSIONS[contentType] ?? ""}`;
+    let filePath = this.bodyFiles.get(a);
+    if (!filePath) {
+      try {
+        filePath = path6.join(this.bodyAttachmentDir(), `${++this.bodyFileCount}-${originalName}`);
+        fs6.writeFileSync(filePath, body);
+        this.bodyFiles.set(a, filePath);
+      } catch (error) {
+        this.logger.warn(`Could not stage attachment "${a.name}" for upload: ${errorMessage(error)}`);
+        return null;
+      }
+    }
+    return { name: a.name || "attachment", path: filePath, contentType, originalName };
+  }
+  bodyAttachmentDir() {
+    if (!this.bodyDir) this.bodyDir = fs6.mkdtempSync(path6.join(os5.tmpdir(), "piwi-dashboard-attachments-"));
+    return this.bodyDir;
+  }
+  warnOversized(a, testCase, size) {
+    const key = `${testCase.location}\0${a.name}`;
+    if (this.oversizedWarned.has(key)) return;
+    this.oversizedWarned.add(key);
+    this.logger.warn(
+      `Skipping attachment "${a.name}" on "${testCase.title}": ${formatMiB(size)} exceeds the ${formatMiB(this.maxAttachmentBytes)} upload limit.`
+    );
+  }
   /** Mapping of well-known report type names to their default output directories */
   getDefaultReportDirs() {
     return {
@@ -950,7 +1076,7 @@ var FileHandler = class {
       blob: "blob-report"
     };
   }
-  /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`) into structured fields on the test case */
+  /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`, `piwi-aria-snapshot-json`) into structured fields on the test case */
   parsePerformanceAttachments(testCase, attachments) {
     const find = (name) => attachments.find((a) => a.name === name);
     const net = find(ATTACHMENT_NAMES.network);
@@ -974,8 +1100,17 @@ var FileHandler = class {
       } catch {
       }
     }
+    const dialogs = find(ATTACHMENT_NAMES.dialogs);
+    if (dialogs?.body) {
+      try {
+        testCase.dialogs = JSON.parse(dialogs.body.toString());
+      } catch {
+      }
+    }
     const aria = find(ATTACHMENT_NAMES.ariaSnapshot);
     if (aria?.body) testCase.ariaSnapshot = aria.body.toString();
+    const ariaJson = find(ATTACHMENT_NAMES.ariaSnapshotJson);
+    if (ariaJson?.body) testCase.ariaSnapshotJson = ariaJson.body.toString();
     const pageState = find(ATTACHMENT_NAMES.pageState);
     if (pageState?.body) {
       try {
@@ -1022,6 +1157,12 @@ var FileHandler = class {
     }
   }
 };
+function safeFileName(name) {
+  return name.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "attachment";
+}
+function formatMiB(bytes) {
+  return `${Math.round(bytes / (1024 * 1024) * 10) / 10} MiB`;
+}
 
 // src/internal/collect/metadata-collector.ts
 var import_node_child_process = require("child_process");
@@ -1055,6 +1196,20 @@ function resolveScmPrNumber(env) {
   const trimmed = raw?.trim();
   return trimmed && /^\d+$/.test(trimmed) ? trimmed : void 0;
 }
+function resolveScmBaseBranch(env) {
+  const override = env.PIWI_BASE_BRANCH?.trim();
+  if (override) return override;
+  let target;
+  if (env.JENKINS_URL) target = env.CHANGE_TARGET;
+  else if (env.GITHUB_ACTIONS) target = env.GITHUB_BASE_REF;
+  else if (env.GITLAB_CI) target = env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME;
+  else if (env.TRAVIS)
+    target = env.TRAVIS_PULL_REQUEST && env.TRAVIS_PULL_REQUEST !== "false" ? env.TRAVIS_BRANCH : void 0;
+  else if (env.TF_BUILD) target = env.SYSTEM_PULLREQUEST_TARGETBRANCH;
+  else if (env.BITBUCKET_BUILD_NUMBER) target = env.BITBUCKET_PR_DESTINATION_BRANCH;
+  const trimmed = target?.trim();
+  return trimmed ? normalizeRef(trimmed) : void 0;
+}
 function normalizeRef(ref) {
   return ref.replace(/^refs\/heads\//, "");
 }
@@ -1122,6 +1277,7 @@ var MetadataCollector = class {
           if (use.colorScheme) config.colorScheme = use.colorScheme;
           if (use.reducedMotion) config.reducedMotion = use.reducedMotion;
           if (use.forcedColors) config.forcedColors = use.forcedColors;
+          if (use.contrast) config.contrast = use.contrast;
           if (use.offline) config.offline = use.offline;
           if (use.bypassCSP) config.bypassCSP = use.bypassCSP;
           if (use.javaScriptEnabled === false) config.javaScriptEnabled = false;
@@ -1186,6 +1342,8 @@ var MetadataCollector = class {
     if (branch) scm.branch = branch;
     const prNumber = resolveScmPrNumber(process.env);
     if (prNumber) scm.prNumber = prNumber;
+    const baseBranch = resolveScmBaseBranch(process.env);
+    if (baseBranch) scm.baseBranch = baseBranch;
     return Object.keys(scm).length > 0 ? scm : void 0;
   }
   collectCiInfo() {
@@ -1264,6 +1422,132 @@ var MetadataCollector = class {
 // src/internal/streaming/stream-manager.ts
 var fs8 = __toESM(require("fs"));
 
+// src/internal/streaming/bounded-queue.ts
+var DROP_TIER = {
+  "step-begin": 0,
+  "step-end": 0,
+  begin: 1,
+  complete: 2
+};
+var CRITICAL_TIER = 2;
+var BoundedEventQueue = class {
+  /**
+   * @param maxBytes Byte budget for the buffered events. `<= 0` or non-finite
+   *   disables the bound (unbounded, i.e. the pre-existing behavior).
+   */
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+    this.items = [];
+    this._bytes = 0;
+    this._peakBytes = 0;
+    this._dropped = 0;
+    this._droppedByType = {};
+    this._lostResults = false;
+  }
+  /** Number of buffered events. */
+  get length() {
+    return this.items.length;
+  }
+  /** Whether the queue holds no events. */
+  get isEmpty() {
+    return this.items.length === 0;
+  }
+  /** Approximate byte size of the buffered events. */
+  get bytes() {
+    return this._bytes;
+  }
+  /** Highest byte size the queue reached over its lifetime. */
+  get peakBytes() {
+    return this._peakBytes;
+  }
+  /** How many events have been dropped by eviction. */
+  get droppedCount() {
+    return this._dropped;
+  }
+  /** Dropped-event counts broken down by event type. */
+  get droppedByType() {
+    return this._droppedByType;
+  }
+  /** True once a test-result (`complete`) event had to be shed — real live-data loss. */
+  get lostResults() {
+    return this._lostResults;
+  }
+  /** Append one event to the back of the queue, then evict if over budget. */
+  enqueue(event) {
+    const size = estimateSize(event);
+    this.items.push({ event, size });
+    this._bytes += size;
+    this.afterGrow();
+  }
+  /**
+   * Put events back at the front (oldest position), preserving their order, then
+   * evict. Used to re-queue a failed flush ahead of anything that arrived while
+   * it was in flight, and to replay events reloaded from the on-disk buffer.
+   */
+  prepend(events) {
+    if (events.length === 0) return;
+    const head = [];
+    let added = 0;
+    for (const event of events) {
+      const size = estimateSize(event);
+      head.push({ event, size });
+      added += size;
+    }
+    this.items = head.concat(this.items);
+    this._bytes += added;
+    this.afterGrow();
+  }
+  /** Remove and return every queued event, resetting the size counter. */
+  takeAll() {
+    const out = this.items.map((it) => it.event);
+    this.items = [];
+    this._bytes = 0;
+    return out;
+  }
+  /** Read the queued events without removing them. */
+  snapshot() {
+    return this.items.map((it) => it.event);
+  }
+  /** Drop every queued event without counting it as an eviction. */
+  clear() {
+    this.items = [];
+    this._bytes = 0;
+  }
+  afterGrow() {
+    if (this._bytes > this._peakBytes) this._peakBytes = this._bytes;
+    this.evict();
+  }
+  // Shed events tier by tier, oldest-first within a tier, until the buffer fits
+  // its budget. A single event larger than the whole budget is kept rather than
+  // leaving the queue empty, so the most recent result always survives.
+  evict() {
+    if (this.maxBytes <= 0 || !Number.isFinite(this.maxBytes)) return;
+    for (let tier = 0; tier <= CRITICAL_TIER && this._bytes > this.maxBytes; tier++) {
+      let i = 0;
+      while (i < this.items.length && this._bytes > this.maxBytes) {
+        if (tier === CRITICAL_TIER && this.items.length <= 1) break;
+        const it = this.items[i];
+        if (DROP_TIER[it.event.type] === tier) {
+          this.items.splice(i, 1);
+          this._bytes -= it.size;
+          this._dropped++;
+          this._droppedByType[it.event.type] = (this._droppedByType[it.event.type] ?? 0) + 1;
+          if (tier === CRITICAL_TIER) this._lostResults = true;
+        } else {
+          i++;
+        }
+      }
+    }
+  }
+};
+function estimateSize(event) {
+  try {
+    return JSON.stringify(event).length;
+  } catch {
+    return 0;
+  }
+}
+
 // src/internal/support/limiter.ts
 function createLimiter(maxConcurrent) {
   const limitValue = Math.max(1, Math.floor(maxConcurrent));
@@ -1288,10 +1572,10 @@ function createLimiter(maxConcurrent) {
 
 // src/internal/support/setup-file.ts
 var path7 = __toESM(require("path"));
-var os5 = __toESM(require("os"));
+var os6 = __toESM(require("os"));
 var fs7 = __toESM(require("fs"));
 function getSetupFilePath(projectName) {
-  return path7.join(os5.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
+  return path7.join(os6.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
 }
 function readSetupInfo(projectName) {
   const setupFile = getSetupFilePath(projectName);
@@ -1330,8 +1614,8 @@ var StreamManager = class {
     this.fileHandler = fileHandler;
     this.options = options;
     this.logger = logger;
-    this.pendingEvents = [];
-    this.pendingBeginEvents = [];
+    /** Guards `reportBufferPressure` so its summary is logged at most once. */
+    this.bufferPressureReported = false;
     this.flushTimer = null;
     this.flushPromises = [];
     this.liveUploadPromises = [];
@@ -1356,6 +1640,9 @@ var StreamManager = class {
     this._token = null;
     this._auth = null;
     this._startPromise = null;
+    const maxBytes = this.options.maxStreamBufferBytes ?? 0;
+    this.pendingEvents = new BoundedEventQueue(maxBytes);
+    this.pendingBeginEvents = new BoundedEventQueue(maxBytes);
   }
   /** Whether the streaming session is active */
   get enabled() {
@@ -1377,6 +1664,15 @@ var StreamManager = class {
   get startPromise() {
     return this._startPromise;
   }
+  /**
+   * Whether buffer pressure forced a test-result (`complete`) event to be
+   * dropped from the live stream. When true the submitter finalizes via the
+   * end-of-run batch (which re-sends the full run from the reporter's own
+   * memory) instead of `/finish`, so the dropped detail is not lost.
+   */
+  get bufferLostResults() {
+    return this.pendingEvents.lostResults || this.pendingBeginEvents.lostResults;
+  }
   /** Begin the streaming session after `onBegin` fires. Non-blocking — the actual handshake runs asynchronously. */
   start(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails) {
     this._startPromise = this._doStart(
@@ -1470,8 +1766,7 @@ var StreamManager = class {
         this.lastActivityAt = Date.now();
         this.scheduleHeartbeat();
         if (this.pendingBeginEvents.length > 0) {
-          this.pendingEvents = [...this.pendingBeginEvents, ...this.pendingEvents];
-          this.pendingBeginEvents = [];
+          this.pendingEvents.prepend(this.pendingBeginEvents.takeAll());
         }
         if (this.pendingEvents.length > 0) this.flush();
       }
@@ -1481,7 +1776,9 @@ var StreamManager = class {
           `Live streaming could not start: the dashboard at ${this.options.serverUrl} requires authentication. Set the reporter's \`apiKey\` option (or PIWI_API_KEY) \u2014 create a key under Settings \u2192 Users on the dashboard. Falling back to batch upload at the end of the run.`
         );
       } else {
-        this.logger.debug(`Streaming not available: ${errorMessage(error)}. Will use batch mode.`);
+        this.logger.warn(
+          `Live streaming is unavailable (${errorMessage(error)}) \u2014 results will be submitted in one batch when the run finishes.`
+        );
       }
       this._enabled = false;
     }
@@ -1493,12 +1790,12 @@ var StreamManager = class {
     if (this._enabled && this._runId) {
       this.queueEvent(event);
     } else {
-      this.pendingBeginEvents.push(event);
+      this.pendingBeginEvents.enqueue(event);
     }
   }
   /** Queue a test-case event. Triggers an immediate flush when the batch size is reached, otherwise schedules a timer-based flush. */
   queueEvent(event) {
-    this.pendingEvents.push(event);
+    this.pendingEvents.enqueue(event);
     if (this.pendingEvents.length >= this.options.streamingBatchSize) {
       this.flush();
     } else if (!this.flushTimer) {
@@ -1511,26 +1808,29 @@ var StreamManager = class {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
-    if (this.pendingEvents.length === 0 || !this._enabled || !this._runId) return null;
-    const events = this.pendingEvents.splice(0);
+    if (this.pendingEvents.isEmpty || !this._enabled || !this._runId) return null;
+    const events = this.pendingEvents.takeAll();
     const promise = this.httpClient.postJSON(`/api/test-runs/${this._runId}/events`, { streamToken: this._token, testCases: events }, this._auth).then(
       () => {
         this.retryCount = 0;
         this.lastActivityAt = Date.now();
         return true;
       },
-      () => {
-        this.pendingEvents = events.concat(this.pendingEvents);
-        this.scheduleRetry();
+      (error) => {
+        this.pendingEvents.prepend(events);
+        this.scheduleRetry(errorMessage(error));
         return false;
       }
     );
     this.flushPromises.push(promise);
     return promise;
   }
-  scheduleRetry() {
+  scheduleRetry(reason) {
     if (this.retryTimer) return;
     this.retryCount++;
+    if (this.retryCount === 1) {
+      this.logger.warn(`Streaming to the dashboard was interrupted (${reason}) \u2014 events are buffered and retried.`);
+    }
     const delay = Math.min(1e3 * Math.pow(2, this.retryCount - 1), this.maxRetryDelay);
     this.logger.debug(`Will retry streaming flush in ${delay}ms (attempt ${this.retryCount})`);
     this.retryTimer = setTimeout(() => {
@@ -1538,7 +1838,7 @@ var StreamManager = class {
       const buffered = this.streamBuffer.load();
       if (buffered.length > 0) {
         this.streamBuffer.clear();
-        this.pendingEvents = buffered.concat(this.pendingEvents);
+        this.pendingEvents.prepend(buffered);
       }
       if (this.pendingEvents.length > 0) this.flush();
     }, delay);
@@ -1581,38 +1881,89 @@ var StreamManager = class {
       this.heartbeatTimer = null;
     }
   }
+  /** Clear a scheduled flush retry so its timer cannot fire after the run wraps up. */
+  clearRetryTimer() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
   /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
   async drain() {
+    try {
+      await this._drain();
+    } finally {
+      this.reportBufferPressure();
+    }
+  }
+  async _drain() {
     this.stopHeartbeat();
+    this.clearRetryTimer();
     if (!this._enabled) {
-      this.pendingEvents = [];
+      this.pendingEvents.clear();
       this.flushPromises = [];
       return;
     }
-    const MAX_ATTEMPTS = 10;
-    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-      if (this._enabled && this.pendingEvents.length > 0) this.flush();
-      if (this.flushPromises.length > 0) {
-        await Promise.allSettled(this.flushPromises);
-        this.flushPromises = [];
-      }
-      if (this.pendingEvents.length === 0) {
-        const buffered = this.streamBuffer.load();
-        if (buffered.length > 0) {
-          this.pendingEvents = buffered;
-          this.streamBuffer.clear();
-          continue;
+    try {
+      const MAX_ATTEMPTS = 10;
+      for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        if (this._enabled && !this.pendingEvents.isEmpty) this.flush();
+        if (this.flushPromises.length > 0) {
+          await Promise.allSettled(this.flushPromises);
+          this.flushPromises = [];
         }
-        return;
+        if (this.pendingEvents.isEmpty) {
+          const buffered = this.streamBuffer.load();
+          if (buffered.length > 0) {
+            this.streamBuffer.clear();
+            this.pendingEvents.prepend(buffered);
+            continue;
+          }
+          return;
+        }
+        if (attempt === 0) {
+          this.logger.warn(
+            `The dashboard has not accepted ${this.pendingEvents.length} live event(s) yet \u2014 retrying delivery before the final submit (this can take a few minutes)...`
+          );
+        }
+        this.logger.debugError(
+          `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
+        );
+        await new Promise((resolve5) => setTimeout(resolve5, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
+      }
+      if (!this.pendingEvents.isEmpty) {
+        const remaining = this.pendingEvents.takeAll();
+        this.logger.warn(
+          `Could not deliver ${remaining.length} live event(s) to the dashboard \u2014 continuing with the end-of-run submit.`
+        );
+        this.streamBuffer.append(remaining);
       }
-      this.logger.debugError(
-        `${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`
+    } finally {
+      this.clearRetryTimer();
+    }
+  }
+  // Emit a single summary when buffer pressure shed events, so a full disk or a
+  // stalled server does not silently swallow data. Reported once per drain.
+  reportBufferPressure() {
+    if (this.bufferPressureReported) return;
+    const dropped = this.pendingEvents.droppedCount + this.pendingBeginEvents.droppedCount;
+    if (dropped === 0) return;
+    this.bufferPressureReported = true;
+    const byType = this.pendingEvents.droppedByType;
+    const beginByType = this.pendingBeginEvents.droppedByType;
+    const count = (type) => (byType[type] ?? 0) + (beginByType[type] ?? 0);
+    const steps = count("step-begin") + count("step-end");
+    const begins = count("begin");
+    const results = count("complete");
+    const limitMb = ((this.options.maxStreamBufferBytes ?? 0) / (1024 * 1024)).toFixed(0);
+    if (results > 0) {
+      this.logger.warn(
+        `Stream buffer hit its ${limitMb} MB limit \u2014 dropped ${dropped} live event(s), including ${results} test result(s) that will not show live on the dashboard (the run's final counts stay accurate, and the end-of-run submit still carries the full run). Raise \`maxStreamBufferBytes\` or check the dashboard connection.`
+      );
+    } else {
+      this.logger.warn(
+        `Stream buffer hit its ${limitMb} MB limit \u2014 dropped ${dropped} live progress event(s) (${steps} step, ${begins} begin) to stay within budget. No test results were lost.`
       );
-      await new Promise((resolve5) => setTimeout(resolve5, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
-    }
-    if (this.pendingEvents.length > 0) {
-      this.streamBuffer.append(this.pendingEvents);
-      this.pendingEvents = [];
     }
   }
   /** Schedule a live upload of trace and attachment files for a test case. Skips cases with no files. Concurrency is limited to 2 simultaneous uploads. */
@@ -1681,15 +2032,26 @@ var StreamManager = class {
   }
 };
 
+// ../core/src/mask.ts
+var DATA_URI_RE = /\bdata:[a-z0-9.+-]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi;
+var JWT_RE = /\beyJ[\w-]{10,}\.[\w-]{5,}\.[\w-]{5,}\b/g;
+var LONG_HEX_RE = /\b[0-9a-f]{32,}\b/gi;
+function maskTokenLike(text) {
+  return text.replace(DATA_URI_RE, "data:[masked]").replace(JWT_RE, "[masked-token]").replace(LONG_HEX_RE, "[masked-hex]");
+}
+
 // ../core/src/step-analysis.ts
-function categorizeStep(title, pwCategory) {
+var MAX_STEP_PARAM_KEYS = 20;
+var MAX_STEP_PARAM_VALUE_CHARS = 200;
+function categorizeStep(title, pwCategory, params) {
   if (!title) return "other";
   if (pwCategory === "hook" || pwCategory === "fixture") return pwCategory;
   if (pwCategory === "expect") return "assertion";
   const lower = title.toLowerCase();
   if (lower.startsWith("wait for") || lower.startsWith("locator.waitfor") || lower.startsWith("page.waitfor") || lower.startsWith("frame.waitfor"))
     return "wait";
-  if (lower.startsWith("navigate to") || lower.startsWith("go back") || lower.startsWith("go forward") || lower.startsWith("reload") || lower.startsWith("page.goto") || lower.startsWith("page.reload") || lower.startsWith("page.goback") || lower.startsWith("page.goforward"))
+  if (typeof params?.url === "string" && pwCategory !== "expect") return "navigation";
+  if (lower.startsWith("navigate") || lower.startsWith("go back") || lower.startsWith("go forward") || lower.startsWith("reload") || lower.startsWith("page.goto") || lower.startsWith("page.reload") || lower.startsWith("page.goback") || lower.startsWith("page.goforward"))
     return "navigation";
   if (lower.startsWith("click") || lower.startsWith("double click") || lower.startsWith("check") || lower.startsWith("uncheck") || lower.startsWith("tap") || lower.startsWith("hover") || lower.startsWith("select option") || lower.startsWith("drag") || lower.startsWith("locator.click") || lower.startsWith("locator.dblclick") || lower.startsWith("locator.check") || lower.startsWith("locator.uncheck") || lower.startsWith("locator.selectoption") || lower.startsWith("locator.tap"))
     return "action";
@@ -1701,14 +2063,39 @@ function categorizeStep(title, pwCategory) {
   if (lower === "before hooks" || lower === "after hooks" || lower.startsWith("fixture:")) return "hook";
   return "other";
 }
+function normalizeStepParams(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  let count = 0;
+  for (const [key, value] of Object.entries(raw)) {
+    if (count >= MAX_STEP_PARAM_KEYS) break;
+    if (typeof value === "number" || typeof value === "boolean") {
+      out[key] = value;
+      count++;
+    } else if (typeof value === "string") {
+      out[key] = maskTokenLike(value).slice(0, MAX_STEP_PARAM_VALUE_CHARS);
+      count++;
+    } else if (value != null) {
+      try {
+        out[key] = maskTokenLike(JSON.stringify(value)).slice(0, MAX_STEP_PARAM_VALUE_CHARS);
+        count++;
+      } catch {
+      }
+    }
+  }
+  return count > 0 ? out : void 0;
+}
 function flattenSteps(steps) {
   const result = [];
   for (const step of steps) {
     const flat = {
       title: step.title,
       duration: step.duration,
-      category: categorizeStep(step.title, step.category)
+      category: categorizeStep(step.title, step.category, step.params)
     };
+    if (typeof step.subtitle === "string" && step.subtitle.length > 0) flat.subtitle = maskTokenLike(step.subtitle);
+    const params = normalizeStepParams(step.params);
+    if (params) flat.params = params;
     if (step.error?.message) {
       flat.error = { message: step.error.message };
       flat.failed = true;
@@ -1864,7 +2251,7 @@ function readSourceSnippet(file, declLine, context, failingLine) {
     return null;
   }
 }
-function collectSourceFrames(errorText, testFile, declLine, opts = {}) {
+function collectSourceFrames(errorText, testFile2, declLine, opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const context = opts.context ?? 8;
   const maxFrames = opts.maxFrames ?? 4;
@@ -1893,9 +2280,9 @@ function collectSourceFrames(errorText, testFile, declLine, opts = {}) {
       if (!isNaN(line)) add(abs, line);
     }
   }
-  const absTest = path9.resolve(testFile);
+  const absTest = path9.resolve(testFile2);
   if (!picked.some((p) => p.absFile === absTest)) {
-    add(absTest, extractFailingLine(errorText, testFile, declLine));
+    add(absTest, extractFailingLine(errorText, testFile2, declLine));
   }
   const frames = [];
   for (const p of picked.slice(0, maxFrames)) {
@@ -1906,9 +2293,9 @@ function collectSourceFrames(errorText, testFile, declLine, opts = {}) {
   }
   return frames;
 }
-function extractFailingLine(errorText, testFile, declarationLine) {
+function extractFailingLine(errorText, testFile2, declarationLine) {
   if (!errorText) return declarationLine;
-  const expectedFile = path9.resolve(testFile);
+  const expectedFile = path9.resolve(testFile2);
   const stackRe = /^\s+at (?:[^(]*\()?(.+?):(\d+):\d+\)?\s*$/gm;
   let m;
   while ((m = stackRe.exec(errorText)) !== null) {
@@ -1996,10 +2383,6 @@ function readSelectionStamp(env = process.env) {
   return { key, version, resolvedHash, resolvedCount };
 }
 
-// src/public/global-setup.ts
-var path10 = __toESM(require("path"));
-var fs11 = __toESM(require("fs"));
-
 // src/internal/support/run-mode.ts
 var PW_UI_FLAGS = ["--ui", "--ui-host", "--ui-port"];
 function isUiMode(argv = process.argv) {
@@ -2008,18 +2391,78 @@ function isUiMode(argv = process.argv) {
   const rest = testIdx >= 0 ? args.slice(testIdx + 1) : args;
   return rest.some((tok) => PW_UI_FLAGS.some((flag) => tok === flag || tok.startsWith(`${flag}=`)));
 }
+var PW_LIST_FLAGS = ["--list"];
+function isListMode(argv = process.argv) {
+  const args = argv.slice(2);
+  const testIdx = args.indexOf("test");
+  const rest = testIdx >= 0 ? args.slice(testIdx + 1) : args;
+  return rest.some((tok) => PW_LIST_FLAGS.some((flag) => tok === flag || tok.startsWith(`${flag}=`)));
+}
+
+// src/public/global-setup.ts
+var path11 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+
+// src/internal/support/aria-sampling.ts
+var path10 = __toESM(require("path"));
+var os7 = __toESM(require("os"));
+var fs11 = __toESM(require("fs"));
+function ariaSampleIdentity(filePath, title) {
+  return `${filePath}\0${title}`;
+}
+function getAriaSampleFilePath(projectName) {
+  return path10.join(os7.tmpdir(), `piwi-dashboard-aria-sample-${hashForProject(projectName)}.json`);
+}
+function writeAriaSampleFile(projectName, identities) {
+  try {
+    fs11.writeFileSync(getAriaSampleFilePath(projectName), JSON.stringify({ projectName, identities }));
+  } catch {
+  }
+}
+function clearAriaSampleFile(projectName) {
+  try {
+    fs11.rmSync(getAriaSampleFilePath(projectName), { force: true });
+  } catch {
+  }
+}
+var cachedSets = /* @__PURE__ */ new Map();
+function loadAriaSampleSet(projectName) {
+  if (cachedSets.has(projectName)) return cachedSets.get(projectName);
+  let set = null;
+  try {
+    const raw = fs11.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"));
+    }
+  } catch {
+    set = null;
+  }
+  cachedSets.set(projectName, set);
+  return set;
+}
+function relativeTestFile(file) {
+  return path10.relative(process.cwd(), file).split(path10.sep).join("/");
+}
+function isDueForAriaSample(testInfo) {
+  const projectName = process.env.PIWI_PROJECT_NAME;
+  if (!projectName) return false;
+  const set = loadAriaSampleSet(projectName);
+  if (!set || set.size === 0) return false;
+  return set.has(ariaSampleIdentity(relativeTestFile(testInfo.file), testInfo.title));
+}
 
 // src/public/global-setup.ts
 function createGlobalSetup(options, userSetup) {
   return async function globalSetupFn(config) {
-    const piwiReporterPath = path10.resolve(__dirname, "./index.js");
+    const piwiReporterPath = path11.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 path10.resolve(require.resolve(r[0])) === piwiReporterPath;
+            return path11.resolve(require.resolve(r[0])) === piwiReporterPath;
           } catch {
             return false;
           }
@@ -2037,6 +2480,11 @@ function createGlobalSetup(options, userSetup) {
       if (userSetup) return userSetup(config);
       return;
     }
+    if (isListMode()) {
+      logger.debug("List mode detected \u2014 skipping run registration.");
+      if (userSetup) return userSetup(config);
+      return;
+    }
     if (opts.enabled === false || !opts.serverUrl) {
       logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
       if (userSetup) return userSetup(config);
@@ -2046,7 +2494,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 path10.resolve(require.resolve(r[0])) === piwiReporterPath;
+        return path11.resolve(require.resolve(r[0])) === piwiReporterPath;
       } catch {
         return false;
       }
@@ -2078,7 +2526,7 @@ function createGlobalSetup(options, userSetup) {
         auth
       );
       if (response?.runId && response?.setupToken) {
-        fs11.writeFileSync(
+        fs12.writeFileSync(
           getSetupFilePath(opts.projectName),
           JSON.stringify({
             runId: response.runId,
@@ -2088,6 +2536,22 @@ 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 menu = await httpClient.getJSON("/api/projects/menu", auth);
+        const 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.`);
+          }
+        }
+      }
     } catch (error) {
       logger.warn(`Could not register global setup: ${errorMessage(error)}`);
     }
@@ -2096,9 +2560,56 @@ function createGlobalSetup(options, userSetup) {
 }
 
 // src/public/config-wrapper.ts
-var path11 = __toESM(require("path"));
-var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
 var PIWI_MODULE = "@piwitests/reporter";
+var CAPTURE_DEFAULTS = {
+  screenshot: "only-on-failure",
+  trace: "retain-on-failure"
+};
+var TRACE_SNAPSHOTS_MIN = { major: 1, minor: 63 };
+function installedPlaywrightVersion() {
+  try {
+    const nodeRequire = require;
+    return nodeRequire("@playwright/test/package.json").version;
+  } catch {
+    return void 0;
+  }
+}
+var readPlaywrightVersion = installedPlaywrightVersion;
+function supportsTraceSnapshots(version) {
+  const match = version ? /^(\d+)\.(\d+)/.exec(version) : null;
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > TRACE_SNAPSHOTS_MIN.major || major === TRACE_SNAPSHOTS_MIN.major && minor >= TRACE_SNAPSHOTS_MIN.minor;
+}
+function applyCaptureDefaults(use, piwiOptions) {
+  delete process.env[PIWI_DEFAULTED_CAPTURE_ENV];
+  const enabled = piwiOptions?.defaultCapture ?? readBool(process.env[PIWI_ENV_KEYS.defaultCapture]) ?? true;
+  if (!enabled) return use;
+  const ariaSnapshots = supportsTraceSnapshots(readPlaywrightVersion());
+  const traceValue = ariaSnapshots ? { mode: CAPTURE_DEFAULTS.trace, snapshots: { dom: true, aria: true } } : CAPTURE_DEFAULTS.trace;
+  const defaults = [
+    { key: "screenshot", value: CAPTURE_DEFAULTS.screenshot, display: `screenshot: '${CAPTURE_DEFAULTS.screenshot}'` },
+    {
+      key: "trace",
+      value: traceValue,
+      display: ariaSnapshots ? `trace: '${CAPTURE_DEFAULTS.trace}' with dom and aria snapshots` : `trace: '${CAPTURE_DEFAULTS.trace}'`
+    }
+  ];
+  const next = { ...use };
+  const applied = [];
+  for (const { key, value, display } of defaults) {
+    if (use?.[key] === void 0) {
+      next[key] = value;
+      applied.push(display);
+    }
+  }
+  if (applied.length === 0) return use;
+  process.env[PIWI_DEFAULTED_CAPTURE_ENV] = applied.join(", ");
+  return next;
+}
 function isPiwiReporterEntry(entry) {
   if (typeof entry === "string") return entry.toLowerCase().includes("piwi");
   if (Array.isArray(entry) && typeof entry[0] === "string") return entry[0].toLowerCase().includes("piwi");
@@ -2115,28 +2626,29 @@ function injectReporter(reporter, piwiOptions) {
 }
 function resolveSetupModule() {
   const candidates = [
-    path11.join(__dirname, "global-setup-module.js"),
-    path11.join(__dirname, "..", "global-setup-module.js"),
-    path11.join(__dirname, "..", "global-setup-module.ts")
+    path12.join(__dirname, "global-setup-module.js"),
+    path12.join(__dirname, "..", "global-setup-module.js"),
+    path12.join(__dirname, "..", "global-setup-module.ts")
   ];
-  return candidates.find((candidate) => fs12.existsSync(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => fs13.existsSync(candidate)) ?? candidates[0];
 }
 function wrapConfig(config, piwiOptions) {
   if (piwiOptions) applyOptionsToEnv(piwiOptions);
-  const globalSetupModules = [];
+  const globalSetupModules = [resolveSetupModule()];
   if (config.globalSetup) {
     const orig = Array.isArray(config.globalSetup) ? config.globalSetup : [config.globalSetup];
     globalSetupModules.push(...orig);
   }
-  globalSetupModules.push(resolveSetupModule());
   const forwarded = {};
   const failOnFlaky = piwiOptions?.failOnFlakyTests ?? readBool(process.env[PIWI_ENV_KEYS.failOnFlakyTests]);
   if (failOnFlaky === true) forwarded.failOnFlakyTests = true;
+  const use = applyCaptureDefaults(config.use, piwiOptions);
   return {
     ...config,
     ...forwarded,
     reporter: injectReporter(config.reporter, piwiOptions),
-    globalSetup: globalSetupModules.length === 1 ? globalSetupModules[0] : globalSetupModules
+    globalSetup: globalSetupModules.length === 1 ? globalSetupModules[0] : globalSetupModules,
+    ...use === config.use ? {} : { use }
   };
 }
 
@@ -2204,6 +2716,8 @@ var PIWI_ANNOTATION_PREFIX = "piwi:";
 var TEST_PRIORITIES = ["critical", "high", "medium", "low"];
 var MAX_TEST_TAGS = 20;
 var MAX_TEST_TAG_CHARS = 60;
+var MAX_TEST_LOCKS = 20;
+var MAX_TEST_LOCK_CHARS = 100;
 var MAX_TEST_META_CHARS = 120;
 var MAX_TEST_LINK_CHARS = 500;
 var PRIORITY_SET = new Set(TEST_PRIORITIES);
@@ -2227,6 +2741,20 @@ function normalizeTestTags(raw) {
   }
   return out;
 }
+function normalizeTestLocks(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") continue;
+    const lock = entry.trim().slice(0, MAX_TEST_LOCK_CHARS);
+    if (!lock || seen.has(lock)) continue;
+    seen.add(lock);
+    out.push(lock);
+    if (out.length >= MAX_TEST_LOCKS) break;
+  }
+  return out;
+}
 function normalizeLink(value) {
   const raw = cleanString(value, MAX_TEST_LINK_CHARS);
   if (!raw) return void 0;
@@ -2279,12 +2807,16 @@ function parseTestMetadata(annotations) {
 function collectTestTags(test) {
   return normalizeTestTags(test.tags);
 }
+function collectTestLocks(test) {
+  const locks = test?._locks;
+  return normalizeTestLocks(locks);
+}
 function collectTestMetadata(annotations) {
   return parseTestMetadata(annotations);
 }
 
 // src/internal/collect/error-text.ts
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 
 // ../core/src/error-text.ts
 function joinErrorMessages(errors) {
@@ -2313,13 +2845,14 @@ function buildErrorText(result) {
   if (!text) return null;
   const loc = result.error?.location;
   if (!loc?.file) return text;
-  const rel = path12.relative(process.cwd(), loc.file).split(path12.sep).join("/");
+  const rel = path13.relative(process.cwd(), loc.file).split(path13.sep).join("/");
   return appendErrorLocation(text, { file: rel, line: loc.line, column: loc.column });
 }
 
 // src/internal/support/ci-output.ts
-var fs13 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var SUMMARY_MAX_FAILURES = 20;
 function emitRunOutputs(output, logger, outputFile, env = process.env) {
   logger.info(`View run: ${output.runUrl}`);
   if (outputFile) writeOutputFile(outputFile, output, logger);
@@ -2328,9 +2861,9 @@ function emitRunOutputs(output, logger, outputFile, env = process.env) {
 }
 function writeOutputFile(file, output, logger) {
   try {
-    const dir = path13.dirname(file);
-    if (dir && dir !== ".") fs13.mkdirSync(dir, { recursive: true });
-    fs13.writeFileSync(
+    const dir = path14.dirname(file);
+    if (dir && dir !== ".") fs14.mkdirSync(dir, { recursive: true });
+    fs14.writeFileSync(
       file,
       JSON.stringify(
         {
@@ -2339,7 +2872,9 @@ function writeOutputFile(file, output, logger) {
           projectId: output.projectId ?? null,
           projectName: output.projectName,
           status: output.status,
-          ciBuildUrl: output.ciBuildUrl ?? null
+          ciBuildUrl: output.ciBuildUrl ?? null,
+          failedCount: output.failures.length,
+          failures: output.failures
         },
         null,
         2
@@ -2354,7 +2889,8 @@ function emitGitHubActions(output, env, logger) {
   const pairs = [
     ["piwi_run_url", output.runUrl],
     ["piwi_run_id", String(output.runId)],
-    ["piwi_run_status", output.status]
+    ["piwi_run_status", output.status],
+    ["piwi_failed_count", String(output.failures.length)]
   ];
   if (output.projectId != null) pairs.push(["piwi_project_id", String(output.projectId)]);
   if (env.GITHUB_OUTPUT) {
@@ -2368,7 +2904,13 @@ function emitGitHubActions(output, env, logger) {
   if (env.GITHUB_STEP_SUMMARY) {
     appendFileLines(
       env.GITHUB_STEP_SUMMARY,
-      ["### Piwi test run", "", `[View run](${output.runUrl}) \u2014 **${output.status}**`, ""],
+      [
+        "### Piwi test run",
+        "",
+        `[View run](${output.runUrl}) \u2014 **${output.status}**`,
+        "",
+        ...summaryFailureLines(output)
+      ],
       logger,
       "step summary"
     );
@@ -2376,13 +2918,32 @@ function emitGitHubActions(output, env, logger) {
   process.stdout.write(`::notice title=Piwi test run::${output.runUrl}
 `);
 }
+function summaryFailureLines(output) {
+  if (output.failures.length === 0) return [];
+  const lines = output.failures.slice(0, SUMMARY_MAX_FAILURES).map((f) => {
+    const headline = f.headline ? ` \u2014 ${escapeMarkdown(f.headline)}` : "";
+    return `- \u274C [${escapeMarkdown(f.title)}](${f.url})${headline} \u2014 \`${f.file}\``;
+  });
+  const hidden = output.failures.length - SUMMARY_MAX_FAILURES;
+  if (hidden > 0) lines.push(`- +${hidden} more`);
+  lines.push("");
+  return lines;
+}
+function escapeMarkdown(text) {
+  return text.replace(/[\\`*_[\]]/g, (ch) => `\\${ch}`);
+}
 function emitGitLabDotenv(output, env, logger) {
   const file = env.PIWI_DOTENV_FILE || "piwi.env";
-  const lines = [`PIWI_RUN_URL=${output.runUrl}`, `PIWI_RUN_ID=${output.runId}`, `PIWI_RUN_STATUS=${output.status}`];
+  const lines = [
+    `PIWI_RUN_URL=${output.runUrl}`,
+    `PIWI_RUN_ID=${output.runId}`,
+    `PIWI_RUN_STATUS=${output.status}`,
+    `PIWI_FAILED_COUNT=${output.failures.length}`
+  ];
   if (output.projectId != null) lines.push(`PIWI_PROJECT_ID=${output.projectId}`);
   if (output.ciBuildUrl) lines.push(`PIWI_CI_BUILD_URL=${output.ciBuildUrl}`);
   try {
-    fs13.writeFileSync(file, lines.join("\n") + "\n");
+    fs14.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)}`);
@@ -2390,7 +2951,7 @@ function emitGitLabDotenv(output, env, logger) {
 }
 function appendFileLines(file, lines, logger, label) {
   try {
-    fs13.appendFileSync(file, lines.join("\n") + "\n");
+    fs14.appendFileSync(file, lines.join("\n") + "\n");
   } catch (error) {
     logger.warn(`Failed to write GitHub Actions ${label}: ${errorMessage(error)}`);
   }
@@ -2409,13 +2970,15 @@ var RunSubmitter = class {
    * @param recovery      Crash-recovery persistence.
    * @param streamManager Streaming session (may be `null` when streaming is disabled).
    * @param logger        Prefixed logger.
+   * @param failureLinks  Failed tests collected during the run, for the per-failure links.
    */
-  constructor(httpClient, uploader, recovery, streamManager, logger = new Logger()) {
+  constructor(httpClient, uploader, recovery, streamManager, logger = new Logger(), failureLinks = null) {
     this.httpClient = httpClient;
     this.uploader = uploader;
     this.recovery = recovery;
     this.streamManager = streamManager;
     this.logger = logger;
+    this.failureLinks = failureLinks;
   }
   /** Run the fallback ladder for a completed test run. */
   async submit(run, result) {
@@ -2443,10 +3006,12 @@ var RunSubmitter = class {
       auth = sm?.auth ?? await this.httpClient.resolveAuth(run.options);
     } catch (error) {
       this.logger.error(`Authentication failed: ${errorMessage(error)}`);
+      this.saveRecovery(this.buildRunPayload(run, overallStatus, duration));
       throw error;
     }
+    if (!sm) await this.recovery.tryUpload(this.httpClient, auth);
     let outcome = { done: false, output: null };
-    if (sm?.enabled && sm?.runId != null) {
+    if (sm?.enabled && sm?.runId != null && !sm.bufferLostResults) {
       outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth);
     }
     if (!outcome.done && (this.hasReports(run) || run.options.uploadTraces)) {
@@ -2455,7 +3020,10 @@ var RunSubmitter = class {
     if (!outcome.done) {
       outcome = await this.tryUploadJSON(run, overallStatus, duration, auth);
     }
-    if (outcome.output) emitRunOutputs(outcome.output, this.logger, run.options.outputFile);
+    if (outcome.output) {
+      this.failureLinks?.printPending(outcome.output.runId);
+      emitRunOutputs(outcome.output, this.logger, run.options.outputFile);
+    }
   }
   /** Assemble a CI-facing run output, or `null` when the server returned no run id. */
   buildOutput(runId, projectId, run, status) {
@@ -2466,7 +3034,8 @@ var RunSubmitter = class {
       projectId,
       projectName: run.options.projectName,
       status,
-      ciBuildUrl: ciBuildUrlFromMetadata(run.metadata)
+      ciBuildUrl: ciBuildUrlFromMetadata(run.metadata),
+      failures: this.failureLinks?.resolve(runId) ?? []
     };
   }
   hasReports(run) {
@@ -2560,17 +3129,15 @@ var RunSubmitter = class {
     }
   }
   async tryUploadWithFiles(run, overallStatus, duration, auth) {
+    const payload = this.buildRunPayload(run, overallStatus, duration);
     try {
-      const response = await this.uploader.uploadWithFiles(
-        this.buildRunPayload(run, overallStatus, duration),
-        this.reportOptions(run),
-        auth
-      );
+      const response = await this.uploader.uploadWithFiles(payload, this.reportOptions(run), auth);
       this.recovery.clear();
       return { done: true, output: this.buildOutput(response?.runId, response?.projectId, run, overallStatus) };
     } catch (error) {
       if (error instanceof HttpError && error.status === 401 && !auth) {
         this.logAuthRequired(run.options.serverUrl);
+        this.saveRecovery(payload);
         throw error;
       }
       this.logger.warn(`Failed to upload with files: ${errorMessage(error)}`);
@@ -2587,16 +3154,24 @@ var RunSubmitter = class {
     } catch (error) {
       if (error instanceof HttpError && error.status === 401 && !auth) {
         this.logAuthRequired(run.options.serverUrl);
+        this.saveRecovery(payload);
         throw error;
       }
       this.logger.error(`All upload methods failed: ${errorMessage(error)}`);
       this.logger.info(
         `Saved a local recovery copy \u2014 it will be uploaded automatically on your next test run. If this keeps happening, check that serverUrl (${run.options.serverUrl ?? "not set"}) is correct and reachable.`
       );
-      this.recovery.save(serializeRun(payload, { includeTestCases: true }));
+      this.saveRecovery(payload);
       return { done: true, output: null };
     }
   }
+  /**
+   * Persist the wire-serialized payload (no raw attachments / internal fields)
+   * so a later run can retry the submit.
+   */
+  saveRecovery(payload) {
+    this.recovery.save(serializeRun(payload, { includeTestCases: true }));
+  }
   /** Log one actionable line explaining how to fix a 401 caused by a missing credential. */
   logAuthRequired(serverUrl) {
     this.logger.error(
@@ -2605,10 +3180,833 @@ var RunSubmitter = class {
   }
 };
 
+// ../core/src/locator-methods.ts
+var LOCATOR_BUILDER_METHODS = [
+  "getByRole",
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "getByPlaceholder",
+  "getByAltText",
+  "getByTitle",
+  "locator"
+];
+
+// ../core/src/error-parse.ts
+var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+var SELECTOR_FN_RE = /\b(?:locator|frameLocator|getByRole|getByTestId|getByText|getByLabel|getByPlaceholder|getByAltText|getByTitle)\(/;
+var CHAIN_LINK_METHODS = /* @__PURE__ */ new Set([
+  ...LOCATOR_BUILDER_METHODS,
+  "frameLocator",
+  "contentFrame",
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "describe"
+]);
+function extractMessageHead(text) {
+  let head = text;
+  const callLogIdx = head.indexOf("\nCall log:");
+  if (callLogIdx !== -1) head = head.slice(0, callLogIdx);
+  const stackIdx = head.search(/\n\s+at /);
+  if (stackIdx !== -1) head = head.slice(0, stackIdx);
+  const lines = head.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  return lines.slice(0, 5).join("\n");
+}
+function extractLeafSelector(text) {
+  const first = SELECTOR_FN_RE.exec(text);
+  if (!first) return null;
+  const nl = text.indexOf("\n", first.index);
+  const region = text.slice(first.index, nl === -1 ? void 0 : nl);
+  let depth = 0;
+  let leafStart = -1;
+  for (let i = 0; i < region.length; i++) {
+    const ch = region[i];
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth > 0) depth--;
+      continue;
+    }
+    if (depth !== 0) continue;
+    const prev = region[i - 1];
+    if (prev && /\w/.test(prev)) continue;
+    for (const method of LOCATOR_BUILDER_METHODS) {
+      if (region.startsWith(method, i) && region[i + method.length] === "(") {
+        leafStart = i;
+        break;
+      }
+    }
+  }
+  if (leafStart === -1) return null;
+  depth = 0;
+  for (let i = leafStart; i < region.length; i++) {
+    const ch = region[i];
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0) return region.slice(leafStart, i + 1);
+    }
+  }
+  return region.slice(leafStart, leafStart + 80);
+}
+function extractLocatorChain(text) {
+  const first = SELECTOR_FN_RE.exec(text);
+  if (!first) return null;
+  const nl = text.indexOf("\n", first.index);
+  const region = text.slice(first.index, nl === -1 ? void 0 : nl);
+  let depth = 0;
+  let end = -1;
+  for (let i = 0; i < region.length; i++) {
+    const ch = region[i];
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      if (depth > 0) depth--;
+      if (depth === 0) {
+        end = i + 1;
+        const link = /^\.(\w+)\(/.exec(region.slice(end));
+        if (!link || !CHAIN_LINK_METHODS.has(link[1])) break;
+        i = end + link[0].length - 2;
+      }
+    }
+  }
+  if (end === -1) return region.slice(0, 80);
+  return region.slice(0, end);
+}
+function extractTopFrame(text) {
+  const frameRe = /^\s+at (?:.*? \()?([^()\s][^()]*?):(\d+):(\d+)\)?\s*$/gm;
+  let m;
+  while ((m = frameRe.exec(text)) !== null) {
+    const file = m[1].replace(/\\/g, "/");
+    if (file.includes("node_modules") || file.startsWith("node:")) continue;
+    return { file, line: Number(m[2]), column: Number(m[3]) };
+  }
+  return null;
+}
+var SUBJECTS = "locator|page|frame|frameLocator|elementHandle|mouse|keyboard|touchscreen|browserContext|browser|apiRequestContext|request|response|route|download|dialog|fileChooser|expect|worker|jsHandle|clock|tracing|video";
+var CALL_RE = new RegExp(`\\b(${SUBJECTS})\\.(\\w+): `);
+var ERROR_NAME_RE = /^((?:[A-Z]\w*)?(?:Error|Exception))\b:?/;
+var MATCHER_RE = /\bexpect(?:\.soft)?\((?:[^()]|\([^()]*\))*\)(\.not)?\.(to\w+)/;
+var MATCHER_SHORT_RE = /\bexpect(?:\.soft)?\.(to\w+)\b/;
+var TIMED_OUT_EXPECT_RE = /Timed out (\d+)ms waiting for expect\(/;
+var NAVIGATION_RE = /\b(?:page|frame)\.(?:goto|waitForURL|waitForNavigation|reload|goBack|goForward)\b|net::ERR_|NS_ERROR_|Navigation failed|navigating to "/i;
+var NETWORK_CODE_RE = /\b(net::ERR_[A-Z0-9_]+|NS_ERROR_[A-Z0-9_]+)\b/;
+var CRASH_RE = /Target page, context or browser has been closed|Target closed|browser has been closed|Browser closed|Page crashed|Navigation failed because page was closed/i;
+var TEST_TIMEOUT_RE = /\bTest timeout of (\d+)ms exceeded(?: while (?:running "(\w+)" hook|tearing down "(\w+)"))?/;
+var STRICT_RE = /strict mode violation: (.+?) resolved to (\d+) elements/;
+var URL_RE = /https?:\/\/[^\s'"`)]+/;
+var CALL_LOG_LINE_RE = /^\s*-\s+(?:(\d+) × )?(.*)$/;
+var RETRY_COUNT_LINE_RE = /^\s+\d+ × (.+)$/;
+function withoutStackFrames(text) {
+  return text.split("\n").filter((line) => !/^\s+at /.test(line)).join("\n");
+}
+function callLogLines(text) {
+  const start = text.indexOf("Call log:");
+  const region = start === -1 ? text : text.slice(start + "Call log:".length);
+  const lines = [];
+  for (const line of region.split("\n")) {
+    const bulleted = CALL_LOG_LINE_RE.exec(line);
+    if (bulleted) {
+      lines.push(bulleted[2].trim());
+      continue;
+    }
+    const retry = RETRY_COUNT_LINE_RE.exec(line);
+    if (retry) lines.push(retry[1].trim());
+  }
+  return lines;
+}
+function readCallLog(text) {
+  const lines = callLogLines(text);
+  const read = {
+    state: "unknown",
+    count: null,
+    lastLine: null,
+    stateLine: null,
+    url: null,
+    timeoutMs: null,
+    matcher: null
+  };
+  if (lines.length === 0) return read;
+  read.lastLine = lines[lines.length - 1];
+  let sawWaiting = false;
+  let waitingLine = null;
+  for (const line of lines) {
+    const before = read.state;
+    const lower = line.toLowerCase();
+    const count = /^locator resolved to (\d+) elements?/.exec(line);
+    const expectLine = /^Expect "(\w+)" with timeout (\d+)ms/.exec(line);
+    const navTo = /navigat(?:ing|ion|ed) to "([^"]+)"/.exec(line);
+    if (expectLine) {
+      read.matcher = expectLine[1];
+      read.timeoutMs = Number(expectLine[2]);
+      continue;
+    }
+    if (navTo) {
+      read.url ??= navTo[1];
+      read.state = "navigating";
+      continue;
+    }
+    if (/^waiting for (?:navigation|page to navigate)/.test(line)) {
+      read.state = "navigating";
+      continue;
+    }
+    if (line.startsWith("waiting for ") && SELECTOR_FN_RE.test(line)) {
+      sawWaiting = true;
+      waitingLine ??= line;
+      continue;
+    }
+    if (count) {
+      read.state = "resolved-count";
+      read.count = Number(count[1]);
+      continue;
+    }
+    if (line.startsWith("locator resolved to hidden <") || line.startsWith('unexpected value "hidden"')) {
+      read.state = "hidden";
+      continue;
+    }
+    if (/^locator resolved to (?:visible )?</.test(line)) {
+      read.state = "resolved";
+      continue;
+    }
+    if (lower.startsWith("element is not visible")) read.state = "not-visible";
+    else if (lower.startsWith("element is not enabled")) read.state = "not-enabled";
+    else if (lower.startsWith("element is not editable")) read.state = "not-editable";
+    else if (lower.startsWith("element is not stable")) read.state = "not-stable";
+    else if (lower.startsWith("element is outside of the viewport")) read.state = "outside-viewport";
+    else if (lower.startsWith("element is not attached") || lower.includes("element was detached"))
+      read.state = "detached";
+    else if (lower.includes("intercepts pointer events")) read.state = "intercepts-pointer";
+    else if (lower.startsWith("element is visible, enabled and stable")) read.state = "resolved";
+    else if (/^(?:attempting|performing) \w+ action/.test(lower) && (read.state === "unknown" || read.state === "not-found"))
+      read.state = "resolved";
+    if (read.state !== before || /^(?:locator resolved to|unexpected value|element is)/.test(lower)) {
+      read.stateLine = line;
+    }
+  }
+  if (read.state === "unknown" && sawWaiting) {
+    read.state = "not-found";
+    read.stateLine = waitingLine;
+  }
+  return read;
+}
+function headerValue(text, label) {
+  const re = new RegExp(`^\\s*${label}(?: string| pattern| substring| value)?:[ \\t]*(.*)$`, "m");
+  const m = re.exec(text);
+  if (!m) return null;
+  const value = m[1].trim();
+  return value.length > 0 ? value : null;
+}
+function readLocator(text, strict) {
+  const header = /^\s*Locator:[ \t]*(.+)$/m.exec(text);
+  if (header) return header[1].trim();
+  if (strict) return strict[1].trim();
+  return extractLocatorChain(text);
+}
+function readTimeout(text, callLog) {
+  const patterns = [
+    /^\s*Timeout:[ \t]*(\d+)ms/m,
+    /\bTimeout (\d+)ms exceeded/,
+    TEST_TIMEOUT_RE,
+    TIMED_OUT_EXPECT_RE,
+    /\bTimed out (\d+)ms/
+  ];
+  for (const re of patterns) {
+    const m = re.exec(text);
+    if (m) return Number(m[1]);
+  }
+  return callLog.timeoutMs;
+}
+function readUrl(text, callLog, received) {
+  if (callLog.url) return callLog.url;
+  const at = /\b(?:net::ERR_[A-Z0-9_]+|NS_ERROR_[A-Z0-9_]+) at (\S+)/.exec(text);
+  if (at) return at[1];
+  const head = extractMessageHead(text);
+  const inHead = URL_RE.exec(head.replace(/^\s*Received.*$/gm, ""));
+  if (inHead) return inHead[0];
+  if (received) {
+    const inReceived = URL_RE.exec(received);
+    if (inReceived) return inReceived[0];
+  }
+  return null;
+}
+function parsePlaywrightError(raw, context) {
+  const clean = stripAnsi(raw ?? "").replace(/\r\n?/g, "\n");
+  const text = withoutStackFrames(clean);
+  const messageHead = extractMessageHead(clean);
+  const firstLine = messageHead.split("\n")[0] ?? "";
+  const errorName = ERROR_NAME_RE.exec(firstLine)?.[1] ?? null;
+  const strict = STRICT_RE.exec(text);
+  const call = CALL_RE.exec(text);
+  const callLog = readCallLog(text);
+  const testTimeout = TEST_TIMEOUT_RE.exec(text);
+  let subject2 = null;
+  let action = null;
+  let assertion = null;
+  let negated = false;
+  if (call) {
+    subject2 = call[1];
+    if (subject2 === "expect") assertion = call[2];
+    else action = call[2];
+  }
+  const matcher = MATCHER_RE.exec(text);
+  const matcherShort = MATCHER_SHORT_RE.exec(text);
+  if (matcher) {
+    assertion = matcher[2];
+    negated = Boolean(matcher[1]);
+  } else if (!assertion && matcherShort) {
+    assertion = matcherShort[1];
+  } else if (!assertion && callLog.matcher) {
+    assertion = callLog.matcher;
+  }
+  if (/\bexpect\((?:[^()]|\([^()]*\))*\)\.not\./.test(text)) negated = true;
+  const isAssertion = assertion !== null || /\bexpect\(|\bexpect\.|Expected (?:string|substring|pattern|value)/.test(text);
+  const isNavigationFailure = NAVIGATION_RE.test(text);
+  const networkErrorCode = NETWORK_CODE_RE.exec(text)?.[1] ?? null;
+  let kind;
+  if (strict) kind = "strict-mode";
+  else if (testTimeout) kind = "test-timeout";
+  else if (CRASH_RE.test(text)) kind = "crash";
+  else if (isAssertion) {
+    const retrying = /^\s*Timeout:[ \t]*\d+ms/m.test(text) || TIMED_OUT_EXPECT_RE.test(text) || callLog.matcher !== null;
+    kind = retrying ? "assertion-timeout" : "assertion";
+  } else if (isNavigationFailure) kind = "navigation";
+  else if (/\bTimeout \d+ms exceeded/.test(text) || errorName === "TimeoutError") kind = "action-timeout";
+  else kind = "unknown";
+  const paramsLocator = typeof context?.stepParams?.locator === "string" ? context.stepParams.locator : null;
+  const paramsUrl = typeof context?.stepParams?.url === "string" ? context.stepParams.url : null;
+  const locator = readLocator(text, strict) ?? paramsLocator;
+  const leafLocator = locator ? extractLeafSelector(locator) : null;
+  const expected = headerValue(text, "Expected");
+  const received = headerValue(text, "Received");
+  const timeoutMs = readTimeout(text, callLog);
+  const url = readUrl(text, callLog, received) ?? paramsUrl;
+  const frame = extractTopFrame(clean);
+  const resolvedCount = strict ? Number(strict[2]) : callLog.count;
+  const lastState = strict ? "resolved-count" : callLog.state;
+  const isLocatorResolutionFailure = kind === "strict-mode" || locator !== null && (lastState === "not-found" || lastState === "resolved-count" && resolvedCount === 0);
+  return {
+    kind,
+    errorName,
+    subject: subject2,
+    action,
+    assertion,
+    negated,
+    locator,
+    leafLocator,
+    expected,
+    received,
+    timeoutMs,
+    url,
+    networkErrorCode,
+    timeoutPhase: testTimeout ? testTimeout[2] ?? testTimeout[3] ?? null : null,
+    lastState,
+    resolvedCount,
+    lastCallLogLine: callLog.lastLine,
+    lastStateLine: callLog.stateLine,
+    messageHead,
+    topFrame: frame ? `${frame.file}:${frame.line}` : null,
+    isNavigationFailure,
+    isLocatorResolutionFailure
+  };
+}
+
+// ../core/src/describe-failure.ts
+var HEADLINE_MAX_CHARS = 120;
+var VALUE_MAX_CHARS = 40;
+var SHORT_VALUE_MAX_CHARS = 20;
+var MASK_TOKEN_RE = /<(?:N|VALUE|URL|STR|UUID|HASH|EMAIL)>/g;
+var ACTION_VERBS = {
+  click: "click",
+  dblclick: "double-click",
+  fill: "fill",
+  type: "type",
+  press: "press",
+  pressSequentially: "type",
+  check: "check",
+  uncheck: "uncheck",
+  hover: "hover",
+  tap: "tap",
+  focus: "focus",
+  blur: "blur",
+  clear: "clear",
+  selectOption: "select",
+  selectText: "select text",
+  setInputFiles: "file upload",
+  setChecked: "check",
+  dragTo: "drag",
+  dragAndDrop: "drag",
+  scrollIntoViewIfNeeded: "scroll",
+  screenshot: "screenshot",
+  waitFor: "wait",
+  waitForSelector: "waitForSelector",
+  waitForLoadState: "waitForLoadState",
+  waitForFunction: "waitForFunction",
+  waitForResponse: "waitForResponse",
+  waitForRequest: "waitForRequest",
+  waitForEvent: "waitForEvent",
+  waitForTimeout: "waitForTimeout",
+  innerText: "read text",
+  textContent: "read text",
+  inputValue: "read value",
+  getAttribute: "read attribute",
+  isVisible: "visibility check",
+  isEnabled: "enabled check",
+  isChecked: "checked check",
+  boundingBox: "measure",
+  evaluate: "evaluate",
+  goto: "navigation"
+};
+var ACTION_GERUNDS = {
+  click: "clicking",
+  dblclick: "double-clicking",
+  fill: "filling",
+  type: "typing into",
+  press: "pressing a key on",
+  pressSequentially: "typing into",
+  check: "checking",
+  uncheck: "unchecking",
+  hover: "hovering",
+  tap: "tapping",
+  focus: "focusing",
+  clear: "clearing",
+  selectOption: "selecting an option in",
+  setInputFiles: "uploading a file to",
+  dragTo: "dragging",
+  waitFor: "waiting for",
+  waitForSelector: "waiting for",
+  evaluate: "evaluating on"
+};
+var STATE_PHRASES = {
+  "not-found": "was not found on the page",
+  hidden: "never became visible",
+  "not-visible": "never became visible",
+  "not-enabled": "never became enabled",
+  "not-editable": "never became editable",
+  "not-stable": "never stopped moving",
+  "outside-viewport": "stayed outside the viewport",
+  "intercepts-pointer": "was covered by another element",
+  detached: "was detached from the DOM",
+  navigating: "was still navigating"
+};
+var STATE_MATCHERS = {
+  toBeVisible: { met: "visible", unmet: "never became visible" },
+  toBeHidden: { met: "hidden", unmet: "never became hidden" },
+  toBeEnabled: { met: "enabled", unmet: "never became enabled" },
+  toBeDisabled: { met: "disabled", unmet: "never became disabled" },
+  toBeChecked: { met: "checked", unmet: "never became checked" },
+  toBeEditable: { met: "editable", unmet: "never became editable" },
+  toBeFocused: { met: "focused", unmet: "never received focus" },
+  toBeAttached: { met: "attached", unmet: "never appeared in the DOM" },
+  toBeDetached: { met: "detached", unmet: "never left the DOM" },
+  toBeInViewport: { met: "in the viewport", unmet: "never entered the viewport" },
+  toBeEmpty: { met: "empty", unmet: "never became empty" }
+};
+var VALUE_MATCHERS = {
+  toHaveText: "text",
+  toContainText: "text containing",
+  toHaveValue: "value",
+  toHaveValues: "values",
+  toHaveAttribute: "attribute",
+  toHaveClass: "class",
+  toContainClass: "class",
+  toHaveId: "id",
+  toHaveCSS: "CSS",
+  toHaveJSProperty: "property",
+  toHaveAccessibleName: "accessible name",
+  toHaveAccessibleDescription: "accessible description",
+  toHaveRole: "role",
+  toHaveURL: "URL",
+  toHaveTitle: "title",
+  toHaveScreenshot: "screenshot",
+  toMatchAriaSnapshot: "ARIA snapshot"
+};
+var NETWORK_ERRORS = {
+  ERR_CONNECTION_REFUSED: "Connection refused loading",
+  ERR_CONNECTION_RESET: "Connection reset loading",
+  ERR_CONNECTION_CLOSED: "Connection closed loading",
+  ERR_CONNECTION_TIMED_OUT: "Connection timed out loading",
+  ERR_TIMED_OUT: "Connection timed out loading",
+  ERR_NAME_NOT_RESOLVED: "DNS lookup failed for",
+  ERR_INTERNET_DISCONNECTED: "No network while loading",
+  ERR_ADDRESS_UNREACHABLE: "Address unreachable loading",
+  ERR_ABORTED: "Navigation aborted loading",
+  ERR_EMPTY_RESPONSE: "Empty response loading",
+  ERR_TOO_MANY_REDIRECTS: "Too many redirects loading",
+  ERR_SSL_PROTOCOL_ERROR: "TLS error loading",
+  ERR_CERT_AUTHORITY_INVALID: "Untrusted certificate loading",
+  ERR_CERT_COMMON_NAME_INVALID: "Certificate name mismatch loading",
+  ERR_CERT_DATE_INVALID: "Expired certificate loading",
+  ERR_BLOCKED_BY_CLIENT: "Request blocked loading",
+  ERR_FAILED: "Request failed loading",
+  ERR_HTTP_RESPONSE_CODE_FAILURE: "HTTP error loading",
+  NS_ERROR_CONNECTION_REFUSED: "Connection refused loading",
+  NS_ERROR_UNKNOWN_HOST: "DNS lookup failed for",
+  NS_ERROR_NET_TIMEOUT: "Connection timed out loading",
+  NS_ERROR_OFFLINE: "No network while loading",
+  NS_ERROR_ABORT: "Navigation aborted loading",
+  NS_BINDING_ABORTED: "Navigation aborted loading"
+};
+function formatTimeout(ms) {
+  if (ms < 1e3) return `${ms} ms`;
+  const seconds = ms / 1e3;
+  const rounded = Math.round(seconds * 10) / 10;
+  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded} s`;
+}
+function routeOf(url) {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.pathname}${parsed.search}` || "/";
+  } catch {
+    return url;
+  }
+}
+function truncateValue(value, max) {
+  const flat = value.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function countNoun(locator, count) {
+  const role = locator ? /getByRole\(\s*['"]([a-z]+)['"]/.exec(locator)?.[1] : null;
+  const noun = role ?? "element";
+  if (count === 1) return noun;
+  return noun.endsWith("s") ? noun : noun.endsWith("x") || noun.endsWith("ch") ? `${noun}es` : `${noun}s`;
+}
+function textOfGetByText(locator) {
+  if (!locator) return null;
+  const m = /^getByText\(\s*(['"`])((?:\\.|(?!\1).)*)\1\s*(?:,\s*\{[^}]*\})?\s*\)$/.exec(locator);
+  return m ? m[2] : null;
+}
+function receivedDisplay(parsed) {
+  const received = parsed.received ?? "";
+  if (parsed.assertion !== "toHaveURL") return received;
+  const m = /^"?(https?:\/\/[^"\s]+)"?$/.exec(received);
+  return m ? `"${routeOf(m[1])}"` : received;
+}
+function firstLineFallback(parsed) {
+  const line = (parsed.messageHead.split("\n")[0] ?? "").replace(/^Error:\s*/, "").replace(MASK_TOKEN_RE, "\u2026");
+  return truncateValue(line || "Unknown error", HEADLINE_MAX_CHARS);
+}
+var Line = class {
+  constructor() {
+    this.parts = [];
+  }
+  text(text) {
+    if (!text) return this;
+    const last = this.parts[this.parts.length - 1];
+    if (last && last.kind === "text") last.text += text;
+    else this.parts.push({ kind: "text", text });
+    return this;
+  }
+  locator(text) {
+    this.parts.push({ kind: "locator", text });
+    return this;
+  }
+  value(text) {
+    this.parts.push({ kind: "value", text });
+    return this;
+  }
+  toString() {
+    return this.parts.map((p) => p.text).join("");
+  }
+};
+function subject(line, locator, opts) {
+  const text = textOfGetByText(locator);
+  if (text !== null) return line.text("Text ").value(`"${truncateValue(text, opts.valueMax)}"`);
+  return line.locator(opts.locator ?? locator ?? "");
+}
+function timeoutSuffix(timeoutMs) {
+  return timeoutMs !== null ? ` after ${formatTimeout(timeoutMs)}` : "";
+}
+function timeoutParen(timeoutMs) {
+  return timeoutMs !== null ? ` (${formatTimeout(timeoutMs)})` : "";
+}
+function buildActionTimeout(parsed, opts) {
+  const line = new Line();
+  const verb = ACTION_VERBS[parsed.action ?? ""] ?? parsed.action ?? "action";
+  const state = STATE_PHRASES[parsed.lastState];
+  if (parsed.locator && state) {
+    return subject(line, parsed.locator, opts).text(` ${state} \u2014 ${verb} timed out`).text(timeoutSuffix(parsed.timeoutMs));
+  }
+  if (parsed.locator && parsed.lastState === "resolved-count" && parsed.resolvedCount !== null) {
+    const count = parsed.resolvedCount;
+    return subject(line, parsed.locator, opts).text(` matched ${count === 0 ? "no" : count} ${countNoun(parsed.locator, count)} \u2014 ${verb} timed out`).text(timeoutSuffix(parsed.timeoutMs));
+  }
+  if (parsed.locator) {
+    return line.text(`${verb} on `).locator(opts.locator ?? parsed.locator).text(" timed out").text(timeoutSuffix(parsed.timeoutMs));
+  }
+  const call = parsed.subject && parsed.action ? `${parsed.subject}.${parsed.action}` : verb;
+  return line.text(`${call} timed out`).text(timeoutSuffix(parsed.timeoutMs));
+}
+function buildAssertion(parsed, opts) {
+  const line = new Line();
+  const matcher = parsed.assertion ?? "expect";
+  const notFound = parsed.lastState === "not-found" || parsed.lastState === "resolved-count" && parsed.resolvedCount === 0 || /element\(s\) not found/.test(parsed.received ?? "");
+  const expected = parsed.expected ? truncateValue(parsed.expected, opts.valueMax) : null;
+  const received = parsed.received ? truncateValue(receivedDisplay(parsed), opts.valueMax) : null;
+  if (matcher === "toHaveCount" && parsed.locator) {
+    const want = Number(parsed.expected);
+    const got = notFound ? 0 : Number(parsed.received);
+    const wantText = Number.isFinite(want) ? String(want) : expected ?? "?";
+    const noun2 = countNoun(parsed.locator, Number.isFinite(want) ? want : 2);
+    const gotText = Number.isFinite(got) ? got === 0 ? "none" : String(got) : received ?? "none";
+    return line.text(`Expected ${wantText} ${noun2}, found ${gotText} \u2014 `).locator(opts.locator ?? parsed.locator).text(" toHaveCount");
+  }
+  const state = STATE_MATCHERS[matcher];
+  if (state) {
+    const unmet = parsed.negated ? `stayed ${state.met}` : state.unmet;
+    if (!parsed.locator) return line.text(`Expected ${state.met}, page ${unmet}`).text(timeoutParen(parsed.timeoutMs));
+    if (notFound && matcher !== "toBeVisible" && matcher !== "toBeAttached") {
+      return subject(line, parsed.locator, opts).text(` was not found on the page \u2014 expected ${state.met}`).text(timeoutParen(parsed.timeoutMs));
+    }
+    return subject(line, parsed.locator, opts).text(` ${unmet}`).text(timeoutParen(parsed.timeoutMs));
+  }
+  const noun = VALUE_MATCHERS[matcher];
+  if (noun) {
+    if (parsed.locator && notFound) {
+      return subject(line, parsed.locator, opts).text(" was not found on the page \u2014 expected ").text(`${noun} `).value(expected ?? "").text(timeoutParen(parsed.timeoutMs));
+    }
+    line.text(`Expected ${noun} `);
+    if (expected) line.value(expected);
+    else line.text("to match");
+    if (received) line.text(", got ").value(received);
+    if (parsed.locator)
+      line.text(" \u2014 ").locator(opts.locator ?? parsed.locator).text(` ${matcher}`);
+    else if (matcher === "toHaveURL" || matcher === "toHaveTitle") line.text(` \u2014 page ${matcher}`);
+    return line;
+  }
+  if (matcher === "toPass") return line.text("expect.toPass never passed").text(timeoutParen(parsed.timeoutMs));
+  if (expected || received) {
+    line.text("Expected ");
+    if (expected) line.value(expected);
+    else line.text("a different value");
+    if (received) line.text(", got ").value(received);
+    line.text(` \u2014 ${matcher}`);
+    if (parsed.locator) line.text(" on ").locator(opts.locator ?? parsed.locator);
+    return line;
+  }
+  if (parsed.locator) {
+    return subject(line, parsed.locator, opts).text(` failed ${matcher}`).text(timeoutParen(parsed.timeoutMs));
+  }
+  return line.text(`${matcher} assertion failed`);
+}
+function buildStrictMode(parsed, opts) {
+  const line = new Line();
+  const count = parsed.resolvedCount ?? 0;
+  if (!parsed.locator) return line.text(`Locator matched ${count} elements \u2014 strict mode`);
+  return line.locator(opts.locator ?? parsed.locator).text(` matched ${count} ${countNoun(parsed.locator, count)} \u2014 strict mode`);
+}
+function buildNavigation(parsed, opts) {
+  const line = new Line();
+  const code = parsed.networkErrorCode?.replace(/^net::/, "") ?? null;
+  if (code) {
+    const phrase = NETWORK_ERRORS[code] ?? `${code.replace(/^(?:ERR|NS_ERROR)_/, "").replace(/_/g, " ").toLowerCase().replace(/^\w/, (c) => c.toUpperCase())} loading`;
+    line.text(phrase);
+    if (parsed.url) line.text(" ").value(truncateValue(parsed.url, opts.valueMax * 2));
+    return line;
+  }
+  const route = parsed.url ? routeOf(parsed.url) : null;
+  const timedOut = parsed.timeoutMs !== null || parsed.errorName === "TimeoutError";
+  if (parsed.action === "waitForURL" || parsed.action === "waitForNavigation") {
+    line.text("Never navigated to ");
+    if (route) line.value(truncateValue(route, opts.valueMax));
+    else line.text("the expected URL");
+    return line.text(` \u2014 ${parsed.action} timed out`).text(timeoutSuffix(parsed.timeoutMs));
+  }
+  line.text("Navigation");
+  if (route) line.text(" to ").value(truncateValue(route, opts.valueMax));
+  if (timedOut) return line.text(" timed out").text(timeoutSuffix(parsed.timeoutMs));
+  return line.text(" failed");
+}
+function buildTestTimeout(parsed, opts, ctx) {
+  const line = new Line().text("Test timed out").text(timeoutSuffix(parsed.timeoutMs));
+  if (parsed.timeoutPhase) {
+    const phase = parsed.timeoutPhase;
+    const isHook = /^(?:before|after)(?:Each|All)$/.test(phase);
+    return line.text(isHook ? ` in the "${phase}" hook` : ` while tearing down "${phase}"`);
+  }
+  if (parsed.isNavigationFailure && parsed.url) {
+    return line.text(" while navigating to ").value(truncateValue(routeOf(parsed.url), opts.valueMax));
+  }
+  if (parsed.assertion && parsed.locator) {
+    const state = STATE_MATCHERS[parsed.assertion];
+    line.text(state ? ` while waiting for ` : " while expecting ");
+    subject(line, parsed.locator, opts);
+    return line.text(state ? ` to be ${state.met}` : ` ${parsed.assertion}`);
+  }
+  if (parsed.action && parsed.locator) {
+    const gerund = ACTION_GERUNDS[parsed.action] ?? `${ACTION_VERBS[parsed.action] ?? parsed.action} on`;
+    line.text(` while ${gerund} `);
+    return subject(line, parsed.locator, opts);
+  }
+  if (parsed.subject && parsed.action) return line.text(` during ${parsed.subject}.${parsed.action}`);
+  const step = ctx?.lastStepTitle?.trim();
+  if (step) return line.text(" while ").value(`"${truncateValue(step, opts.valueMax * 1.5)}"`);
+  return line;
+}
+function buildCrash(parsed, opts) {
+  const line = new Line();
+  const what = /Page crashed/i.test(parsed.messageHead) ? "Page crashed" : "Page or browser closed";
+  if (parsed.action) {
+    const verb = ACTION_VERBS[parsed.action] ?? parsed.action;
+    line.text(`${what} during ${verb}`);
+    if (parsed.locator) line.text(" on ").locator(opts.locator ?? parsed.locator);
+    return line;
+  }
+  if (parsed.assertion && parsed.locator) {
+    return line.text(`${what} while expecting `).locator(opts.locator ?? parsed.locator).text(` ${parsed.assertion}`);
+  }
+  return line.text(what);
+}
+function build(parsed, opts, ctx) {
+  switch (parsed.kind) {
+    case "action-timeout":
+      return buildActionTimeout(parsed, opts);
+    case "assertion":
+    case "assertion-timeout":
+      return buildAssertion(parsed, opts);
+    case "strict-mode":
+      return buildStrictMode(parsed, opts);
+    case "navigation":
+      return buildNavigation(parsed, opts);
+    case "test-timeout":
+      return buildTestTimeout(parsed, opts, ctx);
+    case "crash":
+      return buildCrash(parsed, opts);
+    default:
+      return new Line().text(firstLineFallback(parsed));
+  }
+}
+function detailOf(parsed, headline) {
+  switch (parsed.kind) {
+    case "test-timeout":
+    case "action-timeout": {
+      const state = parsed.lastStateLine;
+      if (!state || parsed.lastState === "not-found" || headline.includes(state)) return null;
+      return truncateValue(state, HEADLINE_MAX_CHARS);
+    }
+    case "assertion":
+    case "assertion-timeout": {
+      const received = parsed.received;
+      if (received && !/element\(s\) not found/.test(received)) {
+        const shown = truncateValue(receivedDisplay(parsed), SHORT_VALUE_MAX_CHARS).slice(0, 8);
+        if (!headline.includes(shown)) return truncateValue(`Received: ${received}`, HEADLINE_MAX_CHARS);
+      }
+      const state = parsed.lastStateLine;
+      if (!state || /^(?:waiting for |unexpected value )/.test(state)) return null;
+      return truncateValue(state, HEADLINE_MAX_CHARS);
+    }
+    case "navigation":
+      return parsed.networkErrorCode ?? parsed.lastStateLine;
+    case "strict-mode":
+    case "crash":
+      return null;
+    default:
+      return null;
+  }
+}
+function describeFailure(parsed, ctx) {
+  const attempts = [
+    { locator: parsed.locator, valueMax: VALUE_MAX_CHARS },
+    { locator: parsed.leafLocator ?? parsed.locator, valueMax: VALUE_MAX_CHARS },
+    { locator: parsed.leafLocator ?? parsed.locator, valueMax: SHORT_VALUE_MAX_CHARS }
+  ];
+  let line = build(parsed, attempts[0], ctx);
+  for (const opts of attempts.slice(1)) {
+    if (line.toString().length <= HEADLINE_MAX_CHARS) break;
+    line = build(parsed, opts, ctx);
+  }
+  let parts = line.parts.map((p) => ({ ...p, text: p.text.replace(MASK_TOKEN_RE, "\u2026") }));
+  let headline = parts.map((p) => p.text).join("");
+  if (headline.length > HEADLINE_MAX_CHARS) {
+    headline = `${headline.slice(0, HEADLINE_MAX_CHARS - 1)}\u2026`;
+    parts = clipParts(parts, HEADLINE_MAX_CHARS - 1);
+    parts.push({ kind: "text", text: "\u2026" });
+  }
+  if (!headline.trim()) {
+    headline = firstLineFallback(parsed);
+    parts = [{ kind: "text", text: headline }];
+  }
+  return { headline, detail: detailOf(parsed, headline), parts };
+}
+function clipParts(parts, max) {
+  const out = [];
+  let used = 0;
+  for (const part of parts) {
+    if (used >= max) break;
+    const text = part.text.slice(0, max - used);
+    if (text) out.push({ kind: part.kind, text });
+    used += text.length;
+  }
+  return out;
+}
+function describeFailureText(raw, ctx) {
+  if (!raw || !raw.trim()) return null;
+  return describeFailure(parsePlaywrightError(raw, { stepParams: ctx?.stepParams }), ctx);
+}
+function lastStepTitle(steps) {
+  if (!steps || steps.length === 0) return null;
+  const failed = steps.find((s) => s.failed);
+  return (failed ?? steps[steps.length - 1])?.title ?? null;
+}
+
+// src/internal/support/failure-links.ts
+function failureHeadline(error, steps) {
+  return describeFailureText(error, { lastStepTitle: lastStepTitle(steps) })?.headline ?? null;
+}
+function caseLocateUrl(serverUrl, runId, test) {
+  const params = [
+    `file=${encodeURIComponent(test.file)}`,
+    `title=${encodeURIComponent(test.title)}`,
+    `retry=${test.retry}`
+  ];
+  if (test.browser) params.push(`browser=${encodeURIComponent(test.browser)}`);
+  return `${serverUrl.replace(/\/+$/, "")}/test-runs/${runId}/locate?${params.join("&")}`;
+}
+function formatFailureLine(link) {
+  const headline = link.headline ? ` \u2014 ${link.headline}` : "";
+  return `\u2717 ${link.title}${headline} \u2192 ${link.url}`;
+}
+var FailureLinks = class {
+  constructor(serverUrl, logger) {
+    this.serverUrl = serverUrl;
+    this.logger = logger;
+    this.failures = [];
+    this.printed = 0;
+  }
+  /** Number of failed tests recorded so far. */
+  get count() {
+    return this.failures.length;
+  }
+  add(test) {
+    this.failures.push(test);
+  }
+  /** Every recorded failure with its link under `runId`. */
+  resolve(runId) {
+    return this.failures.map((test) => ({ ...test, url: caseLocateUrl(this.serverUrl, runId, test) }));
+  }
+  /** Print the lines that have not been printed yet. */
+  printPending(runId) {
+    const links = this.resolve(runId);
+    for (const link of links.slice(this.printed)) this.logger.info(formatFailureLine(link));
+    this.printed = links.length;
+  }
+};
+
 // src/public/reporter.ts
 function testLocation(test) {
-  const relativeFilePath = path14.relative(process.cwd(), test.location.file).split(path14.sep).join("/");
-  return `${relativeFilePath}:${test.location.line}:${test.location.column}`;
+  return `${testFile(test)}:${test.location.line}:${test.location.column}`;
+}
+function testFile(test) {
+  return path15.relative(process.cwd(), test.location.file).split(path15.sep).join("/");
 }
 var PiwiDashboardReporter = class _PiwiDashboardReporter {
   constructor(rawOptions = {}) {
@@ -2640,6 +4038,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.setupSteps = [];
     this.options = resolveOptions(rawOptions);
     this.enabled = this.options.enabled !== false && !!this.options.serverUrl;
+    this.listMode = isListMode();
     this.viaDesktopApp = usedDesktopDiscovery();
     this.runLabel = this.options.runLabel || detectCiRunLabel();
     this.instanceId = computeInstanceId(this.options.projectName, this.runLabel);
@@ -2650,6 +4049,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.uploader = new Uploader(this.httpClient, this.fileHandler, logger);
     this.recovery = new CrashRecovery(this.options.projectName, logger);
     this.metadataCollector = new MetadataCollector(logger);
+    this.failureLinks = new FailureLinks(this.httpClient.baseUrl, logger);
     const streamBuffer = new StreamBuffer(this.options.projectName);
     streamBuffer.clearStale();
     if (this.options.streaming) {
@@ -2663,7 +4063,14 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         logger
       );
     }
-    this.submitter = new RunSubmitter(this.httpClient, this.uploader, this.recovery, this.streamManager, logger);
+    this.submitter = new RunSubmitter(
+      this.httpClient,
+      this.uploader,
+      this.recovery,
+      this.streamManager,
+      logger,
+      this.failureLinks
+    );
   }
   static {
     this.wrapConfig = wrapConfig;
@@ -2673,6 +4080,10 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   }
   /** Playwright reporter hook: called once at the start of the test run */
   onBegin(config, suite) {
+    if (this.listMode) {
+      this.logger.debug("List mode (--list) detected \u2014 no run registered or report uploaded.");
+      return;
+    }
     if (!this.enabled) {
       this.logger.info("Not enabled \u2014 set PIWI_DASHBOARD_URL or serverUrl to enable.");
       return;
@@ -2686,6 +4097,12 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.logger.info(
       `Starting test run for project: ${this.options.projectName} (Playwright v${this.playwrightVersion})`
     );
+    const defaulted = process.env[PIWI_DEFAULTED_CAPTURE_ENV];
+    if (defaulted) {
+      this.logger.info(
+        `Defaulted Playwright ${defaulted} for failure evidence (set defaultCapture: false to opt out).`
+      );
+    }
     const rawConfig = config;
     const grepRe = rawConfig.grep instanceof RegExp ? rawConfig.grep : void 0;
     const grepInvertRe = rawConfig.grepInvert instanceof RegExp ? rawConfig.grepInvert : void 0;
@@ -2756,6 +4173,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     const event = {
       type: "step-begin",
       title: step.title,
+      subtitle: typeof step.subtitle === "string" && step.subtitle.length > 0 ? step.subtitle : null,
       location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
       stepCategory: cat,
       parentTitle: test?.title || null,
@@ -2774,6 +4192,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     const event = {
       type: "step-end",
       title: step.title,
+      subtitle: typeof step.subtitle === "string" && step.subtitle.length > 0 ? step.subtitle : null,
       location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : "unknown",
       status: step.error ? "failed" : "passed",
       duration: step.duration || 0,
@@ -2803,6 +4222,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     const annotations = mergeAnnotations(test, result);
     const status = classifyStatus(result.status, annotations);
     const tags = collectTestTags(test);
+    const locks = collectTestLocks(test);
     const attempts = this.attemptsByTest.get(test.id) ?? [];
     attempts.push({
       retry: result.retry,
@@ -2832,6 +4252,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       suiteConfig,
       testAnnotations: annotations.length ? annotations : null,
       tags: tags.length ? tags : null,
+      locks: locks.length ? locks : null,
       testMeta: collectTestMetadata(annotations),
       // An annotation-less skip reclassified to `didnotrun` is a serial-group
       // cascade: an earlier test failed and Playwright skipped the rest.
@@ -2880,6 +4301,18 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     }
     this.testCases.push(testCase);
     if (status === "didnotrun") linkBlockedTests(this.testCases);
+    const isFailure = status === "failed" || status === "timedOut";
+    if (isFailure && result.retry >= (test.retries ?? 0)) {
+      this.failureLinks.add({
+        title: test.title,
+        file: testFile(test),
+        retry: result.retry,
+        browser: typeof testCase.browser?.projectName === "string" ? testCase.browser.projectName : null,
+        headline: failureHeadline(testCase.error, testCase.performanceMetrics?.steps)
+      });
+    }
+    const liveRunId = this.streamManager?.runId;
+    if (liveRunId != null) this.failureLinks.printPending(liveRunId);
     if (this.streamManager) {
       this.streamManager.queueEvent(toWireTestCase(testCase));
       if (this.options.liveFileUploads) this.streamManager.scheduleLiveUpload(testCase);
@@ -2899,6 +4332,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
       const declaredAnnotations = test.annotations ?? [];
       const tags = collectTestTags(test);
+      const locks = collectTestLocks(test);
       const testCase = {
         type: "complete",
         title: test.title,
@@ -2917,6 +4351,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
         suiteConfig,
         testAnnotations: declaredAnnotations.length ? declaredAnnotations : null,
         tags: tags.length ? tags : null,
+        locks: locks.length ? locks : null,
         testMeta: collectTestMetadata(declaredAnnotations),
         didNotRunReason: reason
       };
@@ -2930,34 +4365,38 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
   }
   /** Playwright reporter hook: called when the full test run finishes */
   async onEnd(result) {
-    if (!this.enabled) return;
+    if (this.listMode || !this.enabled) return;
     const unrunReason = resolveUnrunReason(result?.status, {
       maxFailures: this.maxFailures,
       failures: this.failedTests + this.timedOutTests
     });
     this.materializeUnrunTests(unrunReason);
-    await this.submitter.submit(
-      {
-        options: this.options,
-        testCases: this.testCases,
-        startTime: this.startTime,
-        playwrightVersion: this.playwrightVersion,
-        reporterVersion: this.reporterVersion,
-        totalTests: this.totalTests,
-        passedTests: this.passedTests,
-        failedTests: this.failedTests,
-        skippedTests: this.skippedTests,
-        timedOutTests: this.timedOutTests,
-        didNotRunTests: this.didNotRunTests,
-        metadata: this.metadata,
-        instanceId: this.instanceId,
-        shardInfo: this.shardInfo,
-        setupSteps: this.setupSteps,
-        isFullRun: this.isFullRun,
-        filterDetails: this.filterDetails
-      },
-      result
-    );
+    try {
+      await this.submitter.submit(
+        {
+          options: this.options,
+          testCases: this.testCases,
+          startTime: this.startTime,
+          playwrightVersion: this.playwrightVersion,
+          reporterVersion: this.reporterVersion,
+          totalTests: this.totalTests,
+          passedTests: this.passedTests,
+          failedTests: this.failedTests,
+          skippedTests: this.skippedTests,
+          timedOutTests: this.timedOutTests,
+          didNotRunTests: this.didNotRunTests,
+          metadata: this.metadata,
+          instanceId: this.instanceId,
+          shardInfo: this.shardInfo,
+          setupSteps: this.setupSteps,
+          isFullRun: this.isFullRun,
+          filterDetails: this.filterDetails
+        },
+        result
+      );
+    } finally {
+      this.fileHandler.cleanupBodyAttachments();
+    }
   }
 };
 
@@ -3165,15 +4604,24 @@ function probeElementAttrs(el, arg) {
         let index = -1;
         let levelCount = 0;
         let roleNameCount = 0;
+        let visibleRoleNameCount = 0;
         for (let i = 0; i < nodes.length; i++) {
           const n = nodes[i];
           if (roleOf(n) !== targetRole) continue;
           if (n === el) index = roleCountAll;
           roleCountAll++;
           if (targetLevel != null && levelOf(n) === targetLevel) levelCount++;
-          if (targetName != null && nameOf(n) === targetName) roleNameCount++;
+          if (targetName != null && nameOf(n) === targetName) {
+            roleNameCount++;
+            const node = n;
+            const box = typeof node.getBoundingClientRect === "function" ? node.getBoundingClientRect() : null;
+            if (node.offsetParent != null || !!box && box.width > 0 && box.height > 0) visibleRoleNameCount++;
+          }
+        }
+        if (targetName != null) {
+          selectorCounts.roleName = roleNameCount;
+          selectorCounts.visibleRoleName = visibleRoleNameCount;
         }
-        if (targetName != null) selectorCounts.roleName = roleNameCount;
         if (index !== -1) {
           rolePosition = {
             role: targetRole,
@@ -4384,7 +5832,7 @@ function mergeCandidates(base, extra) {
 }
 
 // src/internal/capture/locator-healing.ts
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 
 // ../core/src/locator-fingerprint.ts
 var ELEMENT_MATCH_SCORES = { role: 60, text: 55, label: 50 };
@@ -4508,18 +5956,6 @@ function freshLocatorsFromCandidate(c) {
   return out;
 }
 
-// ../core/src/locator-methods.ts
-var LOCATOR_BUILDER_METHODS = [
-  "getByRole",
-  "getByTestId",
-  "getByText",
-  "getByLabel",
-  "getByPlaceholder",
-  "getByAltText",
-  "getByTitle",
-  "locator"
-];
-
 // src/internal/capture/locator-healing.ts
 function dedupeSnapshotsByLocation(snaps) {
   const lastWithElement = /* @__PURE__ */ new Map();
@@ -4540,6 +5976,7 @@ var CHAIN_METHODS = [
   "nth",
   "last",
   "filter",
+  "visible",
   "and",
   "or",
   "locator",
@@ -4765,10 +6202,10 @@ function captureCallerLocation(stack = new Error().stack ?? "") {
     }
     let rel = file;
     try {
-      rel = path15.relative(process.cwd(), file);
+      rel = path16.relative(process.cwd(), file);
     } catch {
     }
-    rel = rel.split(path15.sep).join("/");
+    rel = rel.split(path16.sep).join("/");
     if (rel.startsWith("./")) rel = rel.slice(2);
     return `${rel}:${m[3]}:${m[4]}`;
   }
@@ -4811,8 +6248,8 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 }
 
 // src/internal/capture/pick-on-failure.ts
-var path16 = __toESM(require("path"));
-var ANSI_RE = /\[[0-9;]*m/g;
+var path17 = __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++) {
@@ -4899,13 +6336,13 @@ function deriveFailedLocator(testInfo) {
   const errors = info.errors && info.errors.length > 0 ? info.errors : info.error ? [info.error] : [];
   for (const err of errors) {
     const text = `${err.message ?? ""}
-${err.stack ?? ""}`.replace(ANSI_RE, "");
+${err.stack ?? ""}`.replace(ANSI_RE2, "");
     const line = /^\s*Locator:\s*(.+)$/m.exec(text);
     if (!line) continue;
     const parsed = parseLeafLocatorExpression(line[1].trim());
     if (!parsed) continue;
     const loc = err.location;
-    const location = loc ? `${path16.relative(process.cwd(), loc.file).split(path16.sep).join("/")}:${loc.line}:${loc.column}` : null;
+    const location = loc ? `${path17.relative(process.cwd(), loc.file).split(path17.sep).join("/")}:${loc.line}:${loc.column}` : null;
     return { method: parsed.method, args: parsed.args, location };
   }
   return null;
@@ -5087,6 +6524,7 @@ function createSink() {
   return {
     networkRequests: [],
     consoleEntries: [],
+    dialogs: [],
     pendingHandlers: [],
     capturedLocators: [],
     capturePromises: [],
@@ -5097,6 +6535,7 @@ function createSink() {
     stashedWebVitals: null,
     stashedPageState: null,
     stashedAria: null,
+    stashedAriaJson: null,
     pickOffered: false,
     userPick: null
   };
@@ -5285,9 +6724,17 @@ async function stashPageState(sink, closing) {
     if (pageState) sink.stashedPageState = pageState;
   }
   const status = sink.testInfo?.status;
-  if (status === "failed" || status === "timedOut" || status === "interrupted") {
-    const aria = await ariaSnapshotBestEffort(page.locator(":root"), 1e3);
+  const sampleAria = async () => {
+    const root = page.locator(":root");
+    const aria = await ariaSnapshotBestEffort(root, 1e3);
     if (aria) sink.stashedAria = aria;
+    const ariaJson = await ariaSnapshotJSONBestEffort(root, 1e3);
+    if (ariaJson) sink.stashedAriaJson = ariaJson;
+  };
+  if (status === "failed" || status === "timedOut" || status === "interrupted") {
+    await sampleAria();
+  } else if (status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && sink.testInfo && isDueForAriaSample(sink.testInfo)) {
+    await sampleAria();
   }
 }
 async function maybeOpenPicker(sink, closing) {
@@ -5318,6 +6765,7 @@ var INSTRUMENTED_CONTEXTS = /* @__PURE__ */ new WeakSet();
 var PATCHED_BROWSERS = /* @__PURE__ */ new WeakSet();
 var CHAIN_METHOD_SET = new Set(CHAIN_METHODS);
 var ACTION_METHOD_SET = new Set(ACTION_METHODS);
+var LOCATOR_METHOD_SET = new Set(LOCATOR_METHODS);
 var CAPTURED_ATTRS_ARG = {
   keep: [...CAPTURED_ATTRIBUTES],
   tagRoles: TAG_TO_ROLE,
@@ -5370,6 +6818,16 @@ async function ariaSnapshotBestEffort(target, timeout) {
     }
   }
 }
+async function ariaSnapshotJSONBestEffort(target, timeout) {
+  const fn = target.ariaSnapshotJSON;
+  if (typeof fn !== "function") return null;
+  try {
+    const tree = await fn.call(target, timeout != null ? { timeout } : {});
+    return tree == null ? null : JSON.stringify(tree);
+  } catch {
+    return null;
+  }
+}
 function startElementCapture(sink, page, target, seq, callerLocation, used) {
   const probe = probeElement(page, target);
   const settledProbe = probe.then(
@@ -5504,6 +6962,20 @@ function wrapLocator(page, locator, originMethod, originArgs) {
     }
   });
 }
+function wrapFrameLocator(page, frameLocator) {
+  return new Proxy(frameLocator, {
+    get(target, prop) {
+      const original = Reflect.get(target, prop);
+      if (typeof original !== "function") return original;
+      const fn = original;
+      if (!LOCATOR_METHOD_SET.has(prop)) return original;
+      return (...args) => {
+        if (currentSink) currentSink.lastActivePage = page;
+        return wrapLocator(page, fn.apply(target, args), String(prop), args);
+      };
+    }
+  });
+}
 function instrumentPage(page) {
   if (!page || INSTRUMENTED_PAGES.has(page)) return;
   INSTRUMENTED_PAGES.add(page);
@@ -5531,6 +7003,13 @@ function instrumentPage(page) {
         return wrapLocator(page, original(...args), method, args);
       };
     }
+    const originalFrameLocator = typeof page.frameLocator === "function" ? page.frameLocator.bind(page) : null;
+    if (originalFrameLocator) {
+      page.frameLocator = (...args) => {
+        const frame = originalFrameLocator(...args);
+        return args.length === 0 ? wrapFrameLocator(page, frame) : frame;
+      };
+    }
     if (typeof page.on === "function") {
       page.on("framenavigated", () => PROBE_UNSEEDED_PAGES.delete(page));
     }
@@ -5549,6 +7028,24 @@ function instrumentPage(page) {
       });
     }
   });
+  if (typeof page.on === "function") {
+    try {
+      page.on("dialogclosed", (dialog) => {
+        const sink = currentSink;
+        if (!sink) return;
+        try {
+          sink.dialogs.push({
+            type: typeof dialog.type === "function" ? dialog.type() : null,
+            message: typeof dialog.message === "function" ? dialog.message() : null,
+            defaultValue: typeof dialog.defaultValue === "function" ? dialog.defaultValue() || null : null,
+            closedAt: Date.now()
+          });
+        } catch {
+        }
+      });
+    } catch {
+    }
+  }
   page.on("requestfinished", (request) => {
     const sink = currentSink;
     if (!sink) return;
@@ -5675,6 +7172,13 @@ async function flushSink(sink, testInfo) {
           contentType: "text/plain",
           body: snapshot
         });
+        const snapshotJson = (pageReadable ? await ariaSnapshotJSONBestEffort(page.locator(":root")) : null) ?? sink.stashedAriaJson;
+        if (snapshotJson) {
+          await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
+            contentType: "application/json",
+            body: snapshotJson
+          });
+        }
         const failed = sink.failedLocators[sink.failedLocators.length - 1];
         const suggestion = failed ? suggestLocatorsFromAria(failed, snapshot) : null;
         if (suggestion) {
@@ -5691,6 +7195,25 @@ async function flushSink(sink, testInfo) {
     } catch {
     }
   }
+  if (testInfo.status === "passed" && process.env.PIWI_SAMPLE_ARIA_ON_PASS !== "false" && isDueForAriaSample(testInfo)) {
+    try {
+      const snapshot = (pageReadable ? await ariaSnapshotBestEffort(page.locator(":root")) : null) ?? sink.stashedAria;
+      if (snapshot) {
+        await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshot, {
+          contentType: "text/plain",
+          body: snapshot
+        });
+        const snapshotJson = (pageReadable ? await ariaSnapshotJSONBestEffort(page.locator(":root")) : null) ?? sink.stashedAriaJson;
+        if (snapshotJson) {
+          await testInfo.attach(ATTACHMENT_NAMES.ariaSnapshotJson, {
+            contentType: "application/json",
+            body: snapshotJson
+          });
+        }
+      }
+    } catch {
+    }
+  }
   if (sink.userPick) {
     const pick = sink.userPick;
     testInfo.annotations.push({
@@ -5714,6 +7237,12 @@ async function flushSink(sink, testInfo) {
       body: Buffer.from(JSON.stringify(sink.consoleEntries))
     });
   }
+  if (sink.dialogs.length > 0) {
+    await testInfo.attach(ATTACHMENT_NAMES.dialogs, {
+      contentType: "application/json",
+      body: Buffer.from(JSON.stringify(sink.dialogs))
+    });
+  }
   if (sink.networkRequests.length > 0) {
     await testInfo.attach(ATTACHMENT_NAMES.network, {
       contentType: "application/json",
@@ -5777,15 +7306,15 @@ function extendPiwiFixtures(test) {
 }
 
 // src/internal/ai/ai-fixtures.ts
-var fs15 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var import_test = require("@playwright/test");
 
 // src/internal/ai/artifact.ts
-var fs14 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 var ARTIFACT_VERSION = 1;
-var LOCATOR_METHOD_SET = new Set(LOCATOR_METHODS);
+var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET2 = new Set(ACTION_METHODS);
 var POSTCONDITION_ASSERTS = /* @__PURE__ */ new Set([
   "visible",
@@ -5818,7 +7347,7 @@ function validateStructuredLocator(value, where) {
   assert(value !== null && typeof value === "object", `${where}: locator must be an object`);
   const loc = value;
   assert(typeof loc.method === "string", `${where}: locator.method must be a string`);
-  assert(LOCATOR_METHOD_SET.has(loc.method), `${where}: locator method "${String(loc.method)}" is not allowlisted`);
+  assert(LOCATOR_METHOD_SET2.has(loc.method), `${where}: locator method "${String(loc.method)}" is not allowlisted`);
   assert(Array.isArray(loc.args), `${where}: locator.args must be an array`);
   if (loc.chain !== void 0) {
     assert(Array.isArray(loc.chain), `${where}: locator.chain must be an array`);
@@ -5876,7 +7405,7 @@ function parseEntry(text) {
 function readEntry(file) {
   let text;
   try {
-    text = fs14.readFileSync(file, "utf8");
+    text = fs15.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -5886,28 +7415,28 @@ function readEntry(file) {
 function writeEntry(file, entry) {
   const canonical = serializeEntry(entry);
   return withEntryLock(file, () => {
-    if (fs14.existsSync(file) && fs14.readFileSync(file, "utf8") === canonical) return { written: false };
-    fs14.mkdirSync(path17.dirname(file), { recursive: true });
+    if (fs15.existsSync(file) && fs15.readFileSync(file, "utf8") === canonical) return { written: false };
+    fs15.mkdirSync(path18.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs14.writeFileSync(tmp, canonical);
-    fs14.renameSync(tmp, file);
+    fs15.writeFileSync(tmp, canonical);
+    fs15.renameSync(tmp, file);
     return { written: true };
   });
 }
 function withEntryLock(file, fn) {
   const lock = `${file}.lock`;
-  fs14.mkdirSync(path17.dirname(file), { recursive: true });
+  fs15.mkdirSync(path18.dirname(file), { recursive: true });
   const deadline = Date.now() + 5e3;
   for (; ; ) {
     try {
-      const fd = fs14.openSync(lock, "wx");
-      fs14.closeSync(fd);
+      const fd = fs15.openSync(lock, "wx");
+      fs15.closeSync(fd);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() > deadline) {
         try {
-          fs14.unlinkSync(lock);
+          fs15.unlinkSync(lock);
         } catch {
         }
       }
@@ -5917,7 +7446,7 @@ function withEntryLock(file, fn) {
     return fn();
   } finally {
     try {
-      fs14.unlinkSync(lock);
+      fs15.unlinkSync(lock);
     } catch {
     }
   }
@@ -5925,7 +7454,7 @@ function withEntryLock(file, fn) {
 
 // src/internal/ai/keys.ts
 var crypto3 = __toESM(require("crypto"));
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var DEFAULT_AI_DIR = "__piwi__";
 function normalizeTemplate(template) {
   return template.trim().replace(/\s+/g, " ").toLowerCase();
@@ -5939,13 +7468,13 @@ function slug(text, maxLength = 40) {
   return (base || "x").slice(0, maxLength).replace(/-+$/g, "") || "x";
 }
 function entryDir(specFile, dir = DEFAULT_AI_DIR) {
-  return path18.join(path18.dirname(specFile), dir, path18.basename(specFile));
+  return path19.join(path19.dirname(specFile), dir, path19.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 path18.join(entryDir(params.specFile, params.dir), name);
+  return path19.join(entryDir(params.specFile, params.dir), name);
 }
 function parseLocation(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
@@ -6036,7 +7565,7 @@ function isParametric(template, compiledText) {
 }
 
 // src/internal/ai/interpreter.ts
-var LOCATOR_METHOD_SET2 = new Set(LOCATOR_METHODS);
+var LOCATOR_METHOD_SET3 = new Set(LOCATOR_METHODS);
 var ACTION_METHOD_SET3 = new Set(ACTION_METHODS);
 var StepDriftError = class extends Error {
   constructor(step, fingerprint) {
@@ -6074,7 +7603,7 @@ function describePostcondition(post) {
   return post.assert === "url" ? `url \u2192 ${post.url ?? ""}` : `${describeLocator(post.locator)} ${post.assert}`;
 }
 function buildLocator(root, structured, params = {}) {
-  if (!LOCATOR_METHOD_SET2.has(structured.method)) {
+  if (!LOCATOR_METHOD_SET3.has(structured.method)) {
     throw new Error(`piwi AI: locator method "${structured.method}" is not allowlisted`);
   }
   const args = substituteArgs(structured.args, params);
@@ -6399,7 +7928,7 @@ function testIdentity(testInfo) {
   return titles.length > 0 ? titles.join(" \u203A ") : testInfo.title;
 }
 function relativeToCwd(file) {
-  return path19.relative(process.cwd(), file).split(path19.sep).join("/");
+  return path20.relative(process.cwd(), file).split(path20.sep).join("/");
 }
 function recordIntents(intents, entry) {
   const add = (locator, kind) => {
@@ -6426,7 +7955,7 @@ function createAiApi(page, testInfo, config, used, intents) {
   const readSource = () => {
     if (source === null) {
       try {
-        source = fs15.readFileSync(testInfo.file, "utf8");
+        source = fs16.readFileSync(testInfo.file, "utf8");
       } catch {
         source = "";
       }