@piwitests/reporter 0.41.0 → 0.43.0

package/dist/index.js

@@ -89,6 +89,7 @@ var DEFAULTS = {
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
   maxStreamBufferBytes: 100 * 1024 * 1024,
+  submitTimeout: 15 * 60 * 1e3,
   failOnFlakyTests: false,
   username: null,
   password: null,
@@ -110,6 +111,7 @@ var PIWI_ENV_KEYS = {
   streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
   streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
   maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
+  submitTimeout: "PIWI_SUBMIT_TIMEOUT",
   liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
   failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
   uploadTraces: "PIWI_UPLOAD_TRACES",
@@ -143,6 +145,7 @@ var PIWI_SELECTION_ENV = {
   hash: "PIWI_SELECTION_HASH",
   count: "PIWI_SELECTION_COUNT"
 };
+var PIWI_SHARD_ENV = "PIWI_SHARD";
 var PIWI_PROBE_ENV = {
   flag: "PIWI_PROBE",
   plan: "PIWI_PROBE_PLAN",
@@ -171,6 +174,7 @@ var ENV_FALLBACK_SPECS = [
   { 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: "submitTimeout", env: PIWI_ENV_KEYS.submitTimeout, 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" },
@@ -315,13 +319,17 @@ var HttpClient = class {
   /**
    * @param serverUrl Base URL of the Piwi Dashboard server (e.g. `http://localhost:3000`).
    * @param logger    Prefixed logger for verbose diagnostics.
-   * @param timeout   Socket inactivity timeout in ms (default 30s). A hung
-   *                  server now fails fast instead of stalling the reporter.
+   * @param timeout   Socket inactivity timeout in ms (default 30s), so a hung
+   *                  server fails fast rather than stalling the reporter.
    */
   constructor(serverUrl, logger = new Logger(), timeout = 3e4) {
     this.serverUrl = serverUrl;
     this.logger = logger;
     this.timeout = timeout;
+    /** Requests in flight, so `close` can abort them. */
+    this.inFlight = /* @__PURE__ */ new Set();
+    /** Set by `close`: every later request fails with this reason. */
+    this.closedReason = null;
     this.warnIfInsecureTransport();
   }
   /**
@@ -332,7 +340,7 @@ var HttpClient = class {
    * endpoint exposes the key and payloads on the wire. Loopback (localhost /
    * 127.0.0.1 / ::1) is exempt: that traffic never leaves the machine. This
    * warns rather than refuses so internal HTTP deployments (e.g. behind a VPN)
-   * still work, but the exposure is no longer silent.
+   * work, while the exposure is still reported.
    */
   warnIfInsecureTransport() {
     let url;
@@ -353,6 +361,16 @@ var HttpClient = class {
   get baseUrl() {
     return this.serverUrl;
   }
+  /** Whether `close` was called. */
+  get closed() {
+    return this.closedReason !== null;
+  }
+  /** Abort every request in flight and fail every later one with `reason`. */
+  close(reason) {
+    this.closedReason = reason;
+    for (const req of this.inFlight) req.destroy(new Error(reason));
+    this.inFlight.clear();
+  }
   /**
    * Resolve an auth credential: prefer `apiKey`, fall back to `username`/`password` login,
    * or return `null` when neither is configured.
@@ -473,6 +491,10 @@ var HttpClient = class {
   /** Unified request core: transport, headers, auth, response accumulation, timeout. */
   request(method, pathname, opts) {
     return new Promise((resolve6, reject) => {
+      if (this.closedReason !== null) {
+        reject(new Error(this.closedReason));
+        return;
+      }
       const url = new import_node_url.URL(pathname, this.serverUrl);
       const transport = url.protocol === "https:" ? https : http;
       const headers = { ...opts.headers };
@@ -501,11 +523,14 @@ var HttpClient = class {
           });
         }
       );
+      this.inFlight.add(req);
+      req.on("close", () => this.inFlight.delete(req));
       req.on("error", reject);
       req.setTimeout(this.timeout, () => {
         req.destroy(new Error(`Request to ${pathname} timed out after ${this.timeout}ms`));
       });
       if (opts.form) {
+        opts.form.on("error", (error) => req.destroy(error));
         opts.form.pipe(req);
       } else if (opts.body !== void 0) {
         req.write(opts.body);
@@ -864,19 +889,25 @@ function computeInstanceId(projectName, runLabel) {
 // src/internal/streaming/stream-buffer.ts
 var StreamBuffer = class {
   constructor(projectName) {
-    this.filePath = path3.join(os3.tmpdir(), `piwi-dashboard-stream-${hashForProject(projectName)}.jsonl`);
+    this.filePath = null;
+    this.prefix = `piwi-dashboard-stream-${hashForProject(projectName)}`;
+  }
+  /** Scope the buffer to a run. Until then the buffer is empty and appends are dropped. */
+  bindRun(runId) {
+    this.filePath = path3.join(os3.tmpdir(), `${this.prefix}-${runId}.jsonl`);
   }
   /** Append one or more events to the on-disk buffer */
   append(events) {
-    if (events.length === 0) return;
+    if (!this.filePath || events.length === 0) return;
     try {
       const lines = events.map((e) => JSON.stringify(e) + "\n").join("");
       fs3.appendFileSync(this.filePath, lines, "utf8");
     } catch {
     }
   }
-  /** Load all buffered events from disk, clearing the file */
+  /** Load all buffered events of the bound run from disk */
   load() {
+    if (!this.filePath) return [];
     try {
       if (fs3.existsSync(this.filePath)) {
         const content = fs3.readFileSync(this.filePath, "utf8");
@@ -886,23 +917,29 @@ var StreamBuffer = class {
     }
     return [];
   }
-  /** Delete the buffer file from disk */
+  /** Delete the bound run's buffer file from disk */
   clear() {
+    if (!this.filePath) return;
     try {
       if (fs3.existsSync(this.filePath)) fs3.unlinkSync(this.filePath);
     } catch {
     }
   }
-  /** Remove the buffer file if it is older than `maxAgeMs` (default 2 hours). Used on startup to discard orphaned data. */
+  /** Remove this project's buffer files older than `maxAgeMs` (default 2 hours). Used on startup to discard orphaned data. */
   clearStale(maxAgeMs = 72e5) {
+    const dir = os3.tmpdir();
+    let names;
     try {
-      if (fs3.existsSync(this.filePath)) {
-        const stats = fs3.statSync(this.filePath);
-        if (Date.now() - stats.mtimeMs > maxAgeMs) {
-          fs3.unlinkSync(this.filePath);
-        }
-      }
+      names = fs3.readdirSync(dir).filter((name) => name.startsWith(this.prefix));
     } catch {
+      return;
+    }
+    for (const name of names) {
+      try {
+        const file = path3.join(dir, name);
+        if (Date.now() - fs3.statSync(file).mtimeMs > maxAgeMs) fs3.unlinkSync(file);
+      } catch {
+      }
     }
   }
 };
@@ -1331,7 +1368,7 @@ var MetadataCollector = class {
     if (options.tags && Array.isArray(options.tags)) metadata.tags = options.tags;
     if (options.customData) metadata.customData = options.customData;
     if (options.collectScmInfo) {
-      const scm = this.collectScmInfo(options);
+      const scm = this.collectScmInfo();
       if (scm) metadata.scm = scm;
     }
     if (options.collectCiInfo) {
@@ -1425,7 +1462,7 @@ var MetadataCollector = class {
     }
     return { suitePath, suiteConfig };
   }
-  collectScmInfo(_options) {
+  collectScmInfo() {
     const scm = {};
     let gitBranch;
     try {
@@ -1546,7 +1583,7 @@ 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).
+   *   disables the bound (unbounded).
    */
   constructor(maxBytes) {
     this.maxBytes = maxBytes;
@@ -1709,10 +1746,14 @@ function runUrl(serverUrl, runId) {
 }
 
 // src/internal/streaming/stream-manager.ts
+var SERVER_MAX_EVENT_BATCH_BYTES = 10 * 1024 * 1024;
+var EVENT_ENVELOPE_BYTES = 1024;
+var MAX_EVENT_REQUEST_BYTES = 4 * 1024 * 1024;
+var MAX_UPLOAD_CONNECTION_FAILURES = 3;
 var StreamManager = class {
   /**
    * @param httpClient  HTTP client for server communication.
-   * @param streamBuffer On-disk buffer for crash-safe event persistence.
+   * @param streamBuffer On-disk buffer for the run's undelivered events.
    * @param recovery    Crash-recovery handler for uploading stale payloads on startup.
    * @param uploader    Uploader for per-test-case file uploads.
    * @param fileHandler File-discovery helper for finding traces and attachments.
@@ -1748,6 +1789,8 @@ var StreamManager = class {
     this.heartbeatInterval = 15e3;
     /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
     this.uploadedCaseFiles = /* @__PURE__ */ new WeakSet();
+    /** Set when a test-result event left the live stream undelivered: too large to send, or still queued when the drain gave up. */
+    this.resultsUndelivered = false;
     this._enabled = false;
     this._runId = null;
     this._token = null;
@@ -1778,13 +1821,15 @@ var StreamManager = class {
     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.
+   * Whether a test-result (`complete`) event never reached the server through
+   * the live stream: shed under buffer pressure, too large for any request the
+   * server accepts, or still undelivered when the drain gave up. 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 missing
+   * results are not lost.
    */
-  get bufferLostResults() {
-    return this.pendingEvents.lostResults || this.pendingBeginEvents.lostResults;
+  get lostResults() {
+    return this.resultsUndelivered || 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, plannedTotal) {
@@ -1877,6 +1922,7 @@ var StreamManager = class {
         this._runId = response.runId;
         this._token = response.streamToken;
         this._enabled = true;
+        this.streamBuffer.bindRun(response.runId);
         this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
         if (this.options.serverUrl) {
           this.logger.info(`Watch live: ${runUrl(this.options.serverUrl, response.runId)}`);
@@ -1927,21 +1973,78 @@ var StreamManager = class {
       this.flushTimer = null;
     }
     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(
-      () => {
+    const promise = this.sendEvents(this.pendingEvents.takeAll());
+    this.flushPromises.push(promise);
+    return promise;
+  }
+  // Post the events in order, in requests of at most `MAX_EVENT_REQUEST_BYTES`.
+  // A request the server refuses as too large (413) is split in half and resent;
+  // a single event it still refuses leaves the live stream. On any other failure
+  // the unsent events go back to the head of the queue and a retry is scheduled.
+  async sendEvents(events) {
+    const chunks = this.chunkEvents(events);
+    while (chunks.length > 0) {
+      const chunk = chunks.shift();
+      try {
+        await this.httpClient.postJSON(
+          `/api/test-runs/${this._runId}/events`,
+          { streamToken: this._token, testCases: chunk },
+          this._auth
+        );
         this.retryCount = 0;
         this.lastActivityAt = Date.now();
-        return true;
-      },
-      (error) => {
-        this.pendingEvents.prepend(events);
+      } catch (error) {
+        if (error instanceof HttpError && error.status === 413) {
+          if (chunk.length > 1) {
+            const half = Math.ceil(chunk.length / 2);
+            chunks.unshift(chunk.slice(0, half), chunk.slice(half));
+          } else {
+            this.dropOversized(chunk[0]);
+          }
+          continue;
+        }
+        this.pendingEvents.prepend(chunk.concat(...chunks));
         this.scheduleRetry(errorMessage(error));
         return false;
       }
-    );
-    this.flushPromises.push(promise);
-    return promise;
+    }
+    return true;
+  }
+  // Group events into request-sized chunks, keeping their order. An event
+  // larger than any request the server accepts is dropped here.
+  chunkEvents(events) {
+    const chunks = [];
+    let chunk = [];
+    let chunkBytes = 0;
+    for (const event of events) {
+      const bytes = serializedBytes(event);
+      if (bytes > SERVER_MAX_EVENT_BATCH_BYTES - EVENT_ENVELOPE_BYTES) {
+        this.dropOversized(event);
+        continue;
+      }
+      if (chunk.length > 0 && chunkBytes + bytes > MAX_EVENT_REQUEST_BYTES) {
+        chunks.push(chunk);
+        chunk = [];
+        chunkBytes = 0;
+      }
+      chunk.push(event);
+      chunkBytes += bytes;
+    }
+    if (chunk.length > 0) chunks.push(chunk);
+    return chunks;
+  }
+  // Leave an event the server will not accept out of the live stream. A test
+  // result dropped this way sends the run through the end-of-run batch upload,
+  // which carries the full run (see `lostResults`).
+  dropOversized(event) {
+    if (event.type === "complete") {
+      this.resultsUndelivered = true;
+      this.logger.warn(
+        `The live result of "${event.title}" is too large for the dashboard's event stream \u2014 it is sent with the end-of-run upload instead.`
+      );
+    } else {
+      this.logger.debug(`Dropped a ${event.type} event for "${event.title}" that is too large to stream.`);
+    }
   }
   scheduleRetry(reason) {
     if (this.retryTimer) return;
@@ -2006,7 +2109,7 @@ var StreamManager = class {
       this.retryTimer = null;
     }
   }
-  /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
+  /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off, until the HTTP client is closed. */
   async drain() {
     try {
       await this._drain();
@@ -2039,6 +2142,7 @@ var StreamManager = class {
           }
           return;
         }
+        if (this.httpClient.closed) break;
         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)...`
@@ -2051,6 +2155,7 @@ var StreamManager = class {
       }
       if (!this.pendingEvents.isEmpty) {
         const remaining = this.pendingEvents.takeAll();
+        if (remaining.some((event) => event.type === "complete")) this.resultsUndelivered = true;
         this.logger.warn(
           `Could not deliver ${remaining.length} live event(s) to the dashboard \u2014 continuing with the end-of-run submit.`
         );
@@ -2060,6 +2165,10 @@ var StreamManager = class {
       this.clearRetryTimer();
     }
   }
+  /** Delete the run's on-disk event buffer. Called once the run's results reached the server. */
+  discardBuffered() {
+    this.streamBuffer.clear();
+  }
   // 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() {
@@ -2124,13 +2233,18 @@ var StreamManager = class {
     })();
     this.liveUploadPromises.push(promise);
   }
-  /** Wait for all live uploads to settle, then upload files for any test cases that weren't uploaded live */
+  /**
+   * Wait for all live uploads to settle, then upload files for any test cases
+   * that weren't uploaded live. Stops after `MAX_UPLOAD_CONNECTION_FAILURES`
+   * uploads in a row got no response at all.
+   */
   async uploadRemaining(testCases) {
     if (this.liveUploadPromises.length > 0) {
       await Promise.allSettled(this.liveUploadPromises);
       this.liveUploadPromises = [];
     }
     if (!this._enabled || !this._runId || !this._token) return;
+    let connectionFailures = 0;
     for (const tc of testCases) {
       if (this.uploadedCaseFiles.has(tc)) continue;
       try {
@@ -2143,12 +2257,25 @@ var StreamManager = class {
           this._auth
         );
         if (uploaded) this.uploadedCaseFiles.add(tc);
+        connectionFailures = 0;
       } catch (error) {
         this.logger.warn(`Failed to upload files for "${tc.title}": ${errorMessage(error)}`);
+        connectionFailures = error instanceof HttpError ? 0 : connectionFailures + 1;
+        if (connectionFailures >= MAX_UPLOAD_CONNECTION_FAILURES) {
+          this.logger.warn(`The dashboard stopped responding \u2014 skipping the file uploads of the remaining tests.`);
+          return;
+        }
       }
     }
   }
 };
+function serializedBytes(event) {
+  try {
+    return Buffer.byteLength(JSON.stringify(event)) + 1;
+  } catch {
+    return 0;
+  }
+}
 
 // ../core/src/locator-chain.ts
 var LOCATING_METHODS = /* @__PURE__ */ new Set([
@@ -2600,15 +2727,19 @@ function readChain(region) {
   const link = /^\s*\.\s*(\w+)\(/.exec(region.slice(scanned.end));
   return link && CHAIN_LINK_METHODS.has(link[1]) ? null : scanned;
 }
-function extractTopFrame(text) {
+function extractStackFrames(text) {
   const frameRe = /^\s+at (?:.*? \()?([^()\s][^()]*?):(\d+):(\d+)\)?\s*$/gm;
+  const frames = [];
   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]) };
+    frames.push({ file, line: Number(m[2]), column: Number(m[3]) });
   }
-  return null;
+  return frames;
+}
+function extractTopFrame(text) {
+  return extractStackFrames(text)[0] ?? null;
 }
 function extractTopFrameFile(text) {
   return extractTopFrame(text)?.file ?? null;
@@ -2857,6 +2988,13 @@ function maskTokenLike(text) {
   return text.replace(DATA_URI_RE, "data:[masked]").replace(JWT_RE, "[masked-token]").replace(LONG_HEX_RE, "[masked-hex]");
 }
 
+// ../core/src/locator-break.ts
+function sameFilePath(a, b) {
+  const x = a.replace(/\\/g, "/").replace(/^\.\//, "");
+  const y = b.replace(/\\/g, "/").replace(/^\.\//, "");
+  return x === y || x.endsWith("/" + y) || y.endsWith("/" + x);
+}
+
 // ../core/src/step-tree.ts
 var SPAN_TOLERANCE_MS = 1;
 var SETUP_CONTAINER_RE = /^before hooks$/i;
@@ -2878,9 +3016,26 @@ function errorMessage2(step) {
   if (typeof error === "string") return error;
   return str(error?.message);
 }
+function errorLocation(step) {
+  const error = step.error;
+  return typeof error === "string" ? "" : str(error?.location);
+}
+function parseLocation(location) {
+  const m = /^(.+):(\d+):(\d+)$/.exec(location.trim());
+  return m ? { file: m[1], line: Number(m[2]), column: Number(m[3]) } : null;
+}
+function sameCodeLocation(a, b) {
+  const x = typeof a === "string" ? parseLocation(a) : a;
+  const y = typeof b === "string" ? parseLocation(b) : b;
+  if (!x || !y) return false;
+  return x.line === y.line && x.column === y.column && sameFilePath(x.file, y.file);
+}
 function isFailedStep(step) {
   return step.failed === true || errorMessage2(step).trim().length > 0;
 }
+function isRecoveredStep(step) {
+  return step.recovered === true;
+}
 function isCaptureStep(step) {
   const title = str(step.title).trim();
   if (CAPTURE_ATTACH_RE.test(title) || CAPTURE_FIXTURE_RE.test(title)) return true;
@@ -2935,18 +3090,72 @@ function stepPhases(steps, parents = stepParents(steps)) {
     return "body";
   });
 }
-function failingStepIndex(steps, parents = stepParents(steps)) {
+function firstLine(message) {
+  return stripAnsi(str(message)).split("\n")[0].trim();
+}
+function errorHeads(error) {
+  return error.split(/\n---\n/).map(firstLine).filter((head) => head.length > 0);
+}
+function sameError(inner, outer) {
+  const a = firstLine(errorMessage2(inner));
+  const b = firstLine(errorMessage2(outer));
+  if (!a || !b) return true;
+  if (a !== b) return false;
+  const at = errorLocation(inner);
+  const bt = errorLocation(outer);
+  return !at || !bt || sameCodeLocation(at, bt);
+}
+function lastByPhase(indices, phases) {
+  for (const phase of ["body", "setup", "teardown"]) {
+    const inPhase = indices.filter((i) => phases[i] === phase);
+    if (inPhase.length > 0) return inPhase[inPhase.length - 1];
+  }
+  return null;
+}
+function failingChainEnds(steps, parents) {
   const candidates = [];
   steps.forEach((step, i) => {
-    if (isFailedStep(step) && !isCaptureStep(step)) candidates.push(i);
+    if (isFailedStep(step) && !isCaptureStep(step) && !isRecoveredStep(step)) candidates.push(i);
   });
-  if (candidates.length === 0) return null;
-  let current = candidates[0];
-  for (; ; ) {
-    const inner = candidates.find((c) => c > current && isDescendant(c, current, parents));
-    if (inner === void 0) return current;
-    current = inner;
+  const isCandidate = new Set(candidates);
+  const hasFailedAncestor = (i) => {
+    for (let p = parents[i] ?? -1; p !== -1; p = parents[p] ?? -1) if (isCandidate.has(p)) return true;
+    return false;
+  };
+  return candidates.filter((root) => !hasFailedAncestor(root)).map((root) => {
+    let current = root;
+    for (; ; ) {
+      const inner = candidates.filter((c) => c > current && isDescendant(c, current, parents));
+      const carrying = inner.filter((c) => sameError(steps[c], steps[current]));
+      if (carrying.length === 0) return current;
+      current = carrying[carrying.length - 1];
+    }
+  });
+}
+function failingStepIndex(steps, parents = stepParents(steps), error) {
+  const ends = failingChainEnds(steps, parents);
+  if (ends.length === 0) return null;
+  const phases = stepPhases(steps, parents);
+  if (error) {
+    const heads = errorHeads(error);
+    const headOf = (i) => firstLine(errorMessage2(steps[i]));
+    const frame = extractTopFrame(error);
+    if (frame) {
+      const thrownThere = ends.filter(
+        (i) => heads.includes(headOf(i)) && sameCodeLocation(errorLocation(steps[i]) || str(steps[i].location), frame)
+      );
+      const located = lastByPhase(thrownThere, phases);
+      if (located !== null) return located;
+    }
+    for (const head of heads) {
+      const matching = lastByPhase(
+        ends.filter((i) => headOf(i) === head),
+        phases
+      );
+      if (matching !== null) return matching;
+    }
   }
+  return lastByPhase(ends, phases) ?? ends[ends.length - 1];
 }
 function stepHookName(step) {
   const title = str(step.title).trim();
@@ -2959,11 +3168,8 @@ function stepHookName(step) {
   if (category === "hook" && title && !isPhaseContainer(step)) return `hook "${title}"`;
   return null;
 }
-function firstLine(message) {
-  return stripAnsi(str(message)).split("\n")[0].trim();
-}
 function failureHookContext(steps, error, parents = stepParents(steps)) {
-  const index = failingStepIndex(steps, parents);
+  const index = failingStepIndex(steps, parents, error);
   if (index === null) return null;
   const phase = stepPhases(steps, parents)[index];
   if (phase === "body") return null;
@@ -3029,6 +3235,28 @@ function normalizeStepParams(raw) {
   }
   return count > 0 ? out : void 0;
 }
+function locationText(location) {
+  if (!location || typeof location.file !== "string" || !location.file) return void 0;
+  return `${location.file}:${location.line}:${location.column}`;
+}
+function markRecoveredSteps(steps, errors) {
+  const fatal = errors.map((error) => ({
+    head: firstErrorLine(error.message),
+    location: locationText(error.location)
+  }));
+  for (const step of steps) {
+    if (!step.error) continue;
+    const head = firstErrorLine(step.error.message);
+    const thrownAt = step.error.location;
+    const isFatal = fatal.some(
+      (error) => error.head === head && (!error.location || !thrownAt || sameCodeLocation(error.location, thrownAt))
+    );
+    if (!isFatal) step.recovered = true;
+  }
+}
+function firstErrorLine(message) {
+  return stripAnsi(typeof message === "string" ? message : "").split("\n")[0].trim();
+}
 function flattenSteps(steps, depth = 0) {
   const result = [];
   for (const step of steps) {
@@ -3043,17 +3271,21 @@ function flattenSteps(steps, depth = 0) {
     if (params) flat.params = params;
     if (step.error?.message) {
       flat.error = { message: step.error.message };
+      const thrownAt = locationText(step.error.location);
+      if (thrownAt) flat.error.location = thrownAt;
       flat.failed = true;
     }
-    if (step.location) flat.location = `${step.location.file}:${step.location.line}:${step.location.column}`;
+    const location = locationText(step.location);
+    if (location) flat.location = location;
     if (step.startTime) flat.startTime = step.startTime instanceof Date ? step.startTime.getTime() : step.startTime;
     result.push(flat);
     if (step.steps?.length > 0) result.push(...flattenSteps(step.steps, depth + 1));
   }
   return result;
 }
-function collectStepMetrics(steps) {
+function collectStepMetrics(steps, errors) {
   const flatSteps = flattenSteps(steps);
+  if (errors) markRecoveredSteps(flatSteps, errors);
   const totalStepDuration = steps.reduce((sum, s) => sum + (s.duration || 0), 0);
   let slowestStep = null;
   for (const s of flatSteps) {
@@ -3292,22 +3524,30 @@ function extractFailingLine(errorText, testFile2, declarationLine) {
 }
 
 // src/internal/support/ci.ts
-function detectCiRunLabel() {
-  const env = process.env;
-  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) return env.GITHUB_RUN_ID;
-  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return env.CI_PIPELINE_ID;
-  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return env.CIRCLE_WORKFLOW_ID;
-  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return env.TRAVIS_BUILD_ID;
-  if (env.TF_BUILD && env.BUILD_BUILDID) return env.BUILD_BUILDID;
-  if (env.JENKINS_URL && env.BUILD_ID) return env.BUILD_ID;
-  if (env.BUILDKITE_BUILD_ID) return env.BUILDKITE_BUILD_ID;
-  if (env.TEAMCITY_BUILD_ID) return env.TEAMCITY_BUILD_ID;
-  if (env.BITBUCKET_BUILD_NUMBER) return env.BITBUCKET_BUILD_NUMBER;
-  if (env.SEMAPHORE_WORKFLOW_ID) return env.SEMAPHORE_WORKFLOW_ID;
-  if (env.APPVEYOR_BUILD_ID) return env.APPVEYOR_BUILD_ID;
-  if (env.DRONE_BUILD_NUMBER) return env.DRONE_BUILD_NUMBER;
+function detectCiIds(env) {
+  if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID) {
+    const run = env.GITHUB_RUN_ATTEMPT ? `${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT}` : env.GITHUB_RUN_ID;
+    return { run, job: env.GITHUB_JOB || null };
+  }
+  if (env.GITLAB_CI && env.CI_PIPELINE_ID) return { run: env.CI_PIPELINE_ID, job: env.CI_JOB_ID || null };
+  if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID) return { run: env.CIRCLE_WORKFLOW_ID, job: env.CIRCLE_BUILD_NUM || null };
+  if (env.TRAVIS && env.TRAVIS_BUILD_ID) return { run: env.TRAVIS_BUILD_ID, job: env.TRAVIS_JOB_ID || null };
+  if (env.TF_BUILD && env.BUILD_BUILDID) return { run: env.BUILD_BUILDID, job: env.SYSTEM_JOBID || null };
+  if (env.JENKINS_URL && env.BUILD_ID) return { run: env.BUILD_ID, job: null };
+  if (env.BUILDKITE_BUILD_ID) return { run: env.BUILDKITE_BUILD_ID, job: env.BUILDKITE_JOB_ID || null };
+  if (env.TEAMCITY_BUILD_ID) return { run: env.TEAMCITY_BUILD_ID, job: null };
+  if (env.BITBUCKET_BUILD_NUMBER) return { run: env.BITBUCKET_BUILD_NUMBER, job: env.BITBUCKET_STEP_UUID || null };
+  if (env.SEMAPHORE_WORKFLOW_ID) return { run: env.SEMAPHORE_WORKFLOW_ID, job: env.SEMAPHORE_JOB_ID || null };
+  if (env.APPVEYOR_BUILD_ID) return { run: env.APPVEYOR_BUILD_ID, job: env.APPVEYOR_JOB_ID || null };
+  if (env.DRONE_BUILD_NUMBER) return { run: env.DRONE_BUILD_NUMBER, job: null };
   return null;
 }
+function resolveRunLabel(configured, sharded) {
+  if (configured) return configured;
+  const ci = detectCiIds(process.env);
+  if (!ci) return null;
+  return !sharded && ci.job ? `${ci.run}|${ci.job}` : ci.run;
+}
 
 // src/internal/support/worker-index.ts
 function workerIndexOf(result) {
@@ -3363,6 +3603,20 @@ function readSelectionStamp(env = process.env) {
   return { key, version, resolvedHash, resolvedCount };
 }
 
+// src/internal/support/shard-info.ts
+function parseShardSpec(raw) {
+  const match = raw?.trim().match(/^(\d+)\s*\/\s*(\d+)$/);
+  if (!match) return null;
+  const current = Number(match[1]);
+  const total = Number(match[2]);
+  return current >= 1 && current <= total && total > 1 ? { current, total } : null;
+}
+function resolveShardInfo(config, env = process.env) {
+  const pwShard = config.shard;
+  if (pwShard && pwShard.total > 1) return { current: pwShard.current, total: pwShard.total };
+  return parseShardSpec(env[PIWI_SHARD_ENV]);
+}
+
 // src/internal/support/run-mode.ts
 var PW_UI_FLAGS = ["--ui", "--ui-host", "--ui-port"];
 function isUiMode(argv = process.argv) {
@@ -3553,10 +3807,7 @@ function createGlobalSetup(options, userSetup) {
     const httpClient = new HttpClient(opts.serverUrl, logger);
     try {
       const auth = await httpClient.resolveAuth(opts);
-      const runLabel = opts.runLabel || detectCiRunLabel();
-      const pwShard = config.shard;
-      const shardIndex = pwShard?.current;
-      const shardTotal = pwShard?.total;
+      const shard = resolveShardInfo(config);
       const response = await httpClient.postJSON(
         "/api/test-runs/setup",
         {
@@ -3566,9 +3817,9 @@ function createGlobalSetup(options, userSetup) {
           label: opts.label || null,
           keep: opts.keep === true,
           startTime: (/* @__PURE__ */ new Date()).toISOString(),
-          instanceId: computeInstanceId(opts.projectName, runLabel),
-          shardIndex,
-          shardTotal
+          instanceId: computeInstanceId(opts.projectName, resolveRunLabel(opts.runLabel, shard !== null)),
+          shardIndex: shard?.current,
+          shardTotal: shard?.total
         },
         auth
       );
@@ -3745,6 +3996,42 @@ var LONG_HEX_RE2 = /\b[0-9a-f]{8,}\b/gi;
 var SHORT_HEX_RE = /\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*[0-9])[0-9a-f]{6,7}\b/gi;
 var URL_RE2 = /\bhttps?:\/\/[^\s'"`)]+/gi;
 var EMAIL_RE = /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/gi;
+var SELECTOR_OPTION_KEY_RE = /\b(name|hasText|hasNotText|has|placeholder|label|title|alt|exact)\s*:\s*(['"`])/gi;
+var LINE_TERMINATORS = /* @__PURE__ */ new Set(["\n", "\r", "\u2028", "\u2029"]);
+function closingQuoteIndex(text, quote) {
+  const close = new Int32Array(text.length + 1).fill(-1);
+  for (let p = text.length - 1; p >= 0; p--) {
+    const ch = text[p];
+    if (ch === quote) {
+      close[p] = p;
+      continue;
+    }
+    const escaped = ch === "\\" && p + 1 < text.length && !LINE_TERMINATORS.has(text[p + 1]) ? close[p + 2] : -1;
+    close[p] = escaped !== -1 ? escaped : close[p + 1];
+  }
+  return close;
+}
+function maskSelectorOptions(text) {
+  const closers = /* @__PURE__ */ new Map();
+  let out = "";
+  let copied = 0;
+  SELECTOR_OPTION_KEY_RE.lastIndex = 0;
+  let match;
+  while (match = SELECTOR_OPTION_KEY_RE.exec(text)) {
+    const quote = match[2];
+    let close = closers.get(quote);
+    if (!close) closers.set(quote, close = closingQuoteIndex(text, quote));
+    const end = close[SELECTOR_OPTION_KEY_RE.lastIndex];
+    if (end === -1) {
+      SELECTOR_OPTION_KEY_RE.lastIndex = match.index + 1;
+      continue;
+    }
+    out += `${text.slice(copied, match.index)}${match[1]}: <STR>`;
+    copied = end + 1;
+    SELECTOR_OPTION_KEY_RE.lastIndex = copied;
+  }
+  return out + text.slice(copied);
+}
 function classifyError(text) {
   if (/strict mode violation/i.test(text)) return "strict-mode";
   if (/\bexpect\(|\bexpect\.|Expected (?:string|substring|pattern|value)|\.toHave|\.toBe|\.toContain|\.toEqual/.test(text))
@@ -3761,7 +4048,7 @@ function maskVolatile(text) {
 function extractErrorSignature(rawError) {
   const text = stripAnsi(rawError);
   const errorType = classifyError(text);
-  const normalizedMessage = maskVolatile(extractMessageHead(text));
+  const normalizedMessage = maskVolatile(maskSelectorOptions(extractMessageHead(text)));
   const selector = extractSelector(text);
   const topFrameFile = extractTopFrameFile(text);
   const signature = (normalizedMessage.split("\n")[0] || "").slice(0, 200) || "Unknown error";
@@ -4788,6 +5075,7 @@ function ciBuildUrlFromMetadata(metadata) {
 }
 
 // src/internal/submit/run-submitter.ts
+var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 var RunSubmitter = class {
   /**
    * @param httpClient    HTTP client for auth resolution and the finish call.
@@ -4805,8 +5093,28 @@ var RunSubmitter = class {
     this.logger = logger;
     this.failureLinks = failureLinks;
   }
-  /** Run the fallback ladder for a completed test run. */
+  /**
+   * Run the fallback ladder for a completed test run, within the
+   * `submitTimeout` budget. When the budget runs out, every request in flight
+   * and every later one fails, so the ladder falls through to saving the
+   * recovery copy.
+   */
   async submit(run, result) {
+    const budgetMs = run.options.submitTimeout ?? 0;
+    const timer = budgetMs > 0 && Number.isFinite(budgetMs) ? setTimeout(() => this.expireBudget(budgetMs), Math.min(budgetMs, MAX_TIMER_DELAY_MS)) : null;
+    try {
+      await this.submitRun(run, result);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  expireBudget(budgetMs) {
+    this.logger.warn(
+      `The dashboard did not take the run within ${Math.round(budgetMs / 1e3)}s (submitTimeout) \u2014 stopping the upload and saving the results locally.`
+    );
+    this.httpClient.close(`the end-of-run time budget (submitTimeout: ${budgetMs} ms) ran out`);
+  }
+  async submitRun(run, result) {
     const endTime = (/* @__PURE__ */ new Date()).toISOString();
     const duration = new Date(endTime).getTime() - new Date(run.startTime).getTime();
     const counts = computeDistinctRunCounts(run.testCases);
@@ -4843,10 +5151,10 @@ var RunSubmitter = class {
     }
     if (!sm) await this.recovery.tryUpload(this.httpClient, auth);
     let outcome = { done: false, output: null };
-    if (sm?.enabled && sm?.runId != null && !sm.bufferLostResults) {
+    if (sm?.enabled && sm?.runId != null && !sm.lostResults) {
       outcome = await this.tryFinishStreaming(run, overallStatus, duration, auth);
     }
-    if (!outcome.done && (this.hasReports(run) || run.options.uploadTraces)) {
+    if (!outcome.done && !this.httpClient.closed && (this.hasReports(run) || run.options.uploadTraces)) {
       outcome = await this.tryUploadWithFiles(run, overallStatus, duration, auth);
     }
     if (!outcome.done) {
@@ -4941,7 +5249,7 @@ var RunSubmitter = class {
       }
       await this.httpClient.postJSON(`/api/test-runs/${sm.runId}/finish`, finishBody, auth);
       this.logger.info(`Successfully finalized streaming run #${sm.runId}`);
-      this.recovery.clear();
+      this.dropLocalCopies();
       if (this.hasReports(run)) {
         try {
           await this.uploader.uploadReportsForStreamingRun(
@@ -4966,7 +5274,7 @@ var RunSubmitter = class {
     const payload = this.buildRunPayload(run, overallStatus, duration);
     try {
       const response = await this.uploader.uploadWithFiles(payload, this.reportOptions(run), auth);
-      this.recovery.clear();
+      this.dropLocalCopies();
       return { done: true, output: this.buildOutput(response?.runId, response?.projectId, run, overallStatus) };
     } catch (error) {
       if (error instanceof HttpError && error.status === 401 && !auth) {
@@ -4983,7 +5291,7 @@ var RunSubmitter = class {
     const payload = this.buildRunPayload(run, overallStatus, duration);
     try {
       const response = await this.uploader.uploadJSON(payload, auth);
-      this.recovery.clear();
+      this.dropLocalCopies();
       return { done: true, output: this.buildOutput(response?.runId, response?.projectId, run, overallStatus) };
     } catch (error) {
       if (error instanceof HttpError && error.status === 401 && !auth) {
@@ -4999,6 +5307,11 @@ var RunSubmitter = class {
       return { done: true, output: null };
     }
   }
+  /** The run reached the server: drop the recovery copy and the run's buffered live events. */
+  dropLocalCopies() {
+    this.recovery.clear();
+    this.streamManager?.discardBuffered();
+  }
   /**
    * Persist the wire-serialized payload (no raw attachments / internal fields)
    * so a later run can retry the submit.
@@ -5176,7 +5489,7 @@ function countNoun(locator, count) {
 }
 function textOfGetByText(locator) {
   if (!locator) return null;
-  const m = /^getByText\(\s*(['"`])((?:\\.|(?!\1).)*)\1\s*(?:,\s*\{[^}]*\})?\s*\)$/.exec(locator);
+  const m = /^getByText\(\s*(['"`])((?:\\.|(?!\1)[^\\\n\r\u2028\u2029])*)\1\s*(?:,\s*\{[^}]*\})?\s*\)$/.exec(locator);
   return m ? m[2] : null;
 }
 function receivedDisplay(parsed) {
@@ -5466,10 +5779,10 @@ function describeFailureText(raw, ctx) {
   if (!raw || !raw.trim()) return null;
   return describeFailure(parsePlaywrightError(raw, { stepParams: ctx?.stepParams }), ctx);
 }
-function headlineStep(steps) {
+function headlineStep(steps, error) {
   if (!steps || steps.length === 0) return null;
   const parents = stepParents(steps);
-  const failed = failingStepIndex(steps, parents);
+  const failed = failingStepIndex(steps, parents, error);
   if (failed !== null) return steps[failed];
   const phases = stepPhases(steps, parents);
   for (let i = steps.length - 1; i >= 0; i--) {
@@ -5478,17 +5791,17 @@ function headlineStep(steps) {
   }
   return steps[steps.length - 1];
 }
-function lastStepTitle(steps) {
-  const title = headlineStep(steps)?.title;
+function lastStepTitle(steps, error) {
+  const title = headlineStep(steps, error)?.title;
   return typeof title === "string" ? title : null;
 }
-function failingStepParams(steps) {
-  return headlineStep(steps)?.params ?? null;
+function failingStepParams(steps, error) {
+  return headlineStep(steps, error)?.params ?? null;
 }
 function stepHeadlineContext(steps, error) {
   return {
-    lastStepTitle: lastStepTitle(steps),
-    stepParams: failingStepParams(steps),
+    lastStepTitle: lastStepTitle(steps, error),
+    stepParams: failingStepParams(steps, error),
     failedIn: steps && steps.length > 0 ? failureHookContext(steps, error ?? null) : null
   };
 }
@@ -5561,7 +5874,8 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     this.reportedTestIds = /* @__PURE__ */ new Set();
     /** Per-test attempt history, keyed by `test.id`; snapshotted onto every attempt's payload. */
     this.attemptsByTest = /* @__PURE__ */ new Map();
-    this.runLabel = null;
+    /** Derived in `onBegin`, once the shard is known. */
+    this.instanceId = "";
     this.shardInfo = null;
     this.metadata = {};
     this.isFullRun = true;
@@ -5575,8 +5889,6 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
     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);
     const logger = new Logger(this.options.verbose ?? false);
     this.logger = logger;
     this.httpClient = new HttpClient(this.options.serverUrl ?? "http://localhost:3000", logger);
@@ -5670,11 +5982,14 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       this.metadata = flakeRunMetadata(stamp, this.metadata);
     }
     this.plannedTests = suite.allTests();
-    const pwShard = config.shard;
-    if (pwShard?.total && pwShard.total > 1) {
-      this.shardInfo = { current: pwShard.current, total: pwShard.total };
+    this.shardInfo = resolveShardInfo(config);
+    if (this.shardInfo) {
       this.logger.info(`Shard ${this.shardInfo.current}/${this.shardInfo.total} detected`);
     }
+    this.instanceId = computeInstanceId(
+      this.options.projectName,
+      resolveRunLabel(this.options.runLabel, this.shardInfo !== null)
+    );
     this.streamManager?.start(
       this.startTime,
       this.metadata,
@@ -5827,7 +6142,7 @@ var PiwiDashboardReporter = class _PiwiDashboardReporter {
       if (frames.length) testCase.testSourceFrames = frames;
     }
     if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
-      testCase.performanceMetrics = collectStepMetrics(result.steps);
+      testCase.performanceMetrics = collectStepMetrics(result.steps, result.errors);
       const stepEvents = extractTestStepEvents(result.steps, result.startTime);
       const waitEvents = extractWaitEvents(result.steps);
       const allEvents = [...stepEvents, ...waitEvents];
@@ -6398,7 +6713,7 @@ function installPickerOverlay(arg) {
   banner.style.cssText = `position:fixed;top:12px;left:50%;transform:translateX(-50%);z-index:${Z + 2};background:#111827;color:#f9fafb;font:13px/1.5 system-ui,sans-serif;border:1px solid #312e81;padding:10px 16px;border-radius:10px;box-shadow:0 4px 24px rgba(0,0,0,.5);max-width:min(680px,86vw);`;
   const hlTokens = (expr) => {
     const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    const re = /('(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
     let html = "";
     let last = 0;
     let m;
@@ -6941,7 +7256,7 @@ function showPickerChoices(arg) {
   panel.style.cssText = "background:#111827;color:#f9fafb;border-radius:10px;padding:20px;max-width:640px;width:90vw;max-height:70vh;overflow:auto;box-shadow:0 8px 40px rgba(0,0,0,.5);";
   const hlLocator = (expr) => {
     const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    const re = /('(?:\\.|[^'])*'|"(?:\\.|[^"])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
+    const re = /('(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*")|([A-Za-z_$][\w$]*)(?=\s*\()|([A-Za-z_$][\w$]*)(?=\s*:)|(true|false|null|\d+)|([{}(),.])/g;
     let html = "";
     let last = 0;
     let m;
@@ -8030,7 +8345,7 @@ function inspectionGateFromTestInfo(testInfo, enabled = process.env.PIWI_INSPECT
 
 // src/internal/capture/pick-on-failure.ts
 var path20 = __toESM(require("path"));
-var ANSI_RE2 = /\[[0-9;]*m/g;
+var ANSI_RE2 = /\x1b\[[0-9;]*m/g;
 function parseLeafLocatorExpression(rawExpr) {
   const leaf = parseLeafLocatorCall(rawExpr);
   return leaf ? { method: leaf.method, args: locatorCallValues(leaf) } : null;
@@ -9938,15 +10253,15 @@ function entryPath(params) {
   const name = `${slug(params.testTitle)}.${slug(params.template)}.${hash}.json`;
   return path25.join(entryDir(params.specFile, params.dir), name);
 }
-function parseLocation(location) {
+function parseLocation2(location) {
   const match = /:(\d+):(\d+)$/.exec(location);
   if (!match) return null;
   return { line: Number(match[1]), col: Number(match[2]) };
 }
 function orderByPosition(locations) {
   return [...new Set(locations)].sort((a, b) => {
-    const pa = parseLocation(a);
-    const pb = parseLocation(b);
+    const pa = parseLocation2(a);
+    const pb = parseLocation2(b);
     if (!pa || !pb) return a < b ? -1 : a > b ? 1 : 0;
     return pa.line - pb.line || pa.col - pb.col;
   });