@piwitests/reporter 0.27.0 → 0.28.0

package/README.md

@@ -38,6 +38,8 @@ export default wrapConfig(defineConfig({}), {
 
 Run `npx playwright test` — results are uploaded automatically.
 
+> Piwi rebuilds the run from the data it collects, so you don't also need Playwright's built-in `html` reporter — running it alongside Piwi just repeats the end-of-run report generation. Keep it only if you want Playwright's standalone report uploaded too.
+
 **Recommended: enable the capture fixtures.** One small file unlocks the dashboard's richest features:
 
 ```typescript

package/dist/global-setup-module.js

@@ -83,6 +83,7 @@ var DEFAULTS = {
   streaming: true,
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
   failOnFlakyTests: false,
   username: null,
   password: null,
@@ -102,6 +103,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",
@@ -140,6 +142,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" },
@@ -389,6 +392,12 @@ var HttpClient = class {
           res.on("end", () => {
             resolve2({ 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);
@@ -483,6 +492,13 @@ 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
 function createGlobalSetup(options, userSetup) {
@@ -512,6 +528,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);

package/dist/index.d.ts

@@ -115,6 +115,18 @@ interface PiwiDashboardOptions {
     streamingBatchSize?: number;
     /** Max delay (ms) before flushing pending events during streaming. Defaults to `2000`. */
     streamingBatchDelay?: number;
+    /**
+     * Byte budget for the in-memory stream buffer (the queue of events waiting to
+     * reach the dashboard, and the crash-recovery file it writes if delivery
+     * fails). When the server is unreachable or a huge suite outruns delivery, the
+     * queue is capped here instead of growing without bound: the lowest-value
+     * events are shed first — live step progress, then per-test `begin` markers,
+     * and only as a last resort test results (the final counts and the end-of-run
+     * batch submit stay complete regardless). Defaults to `104857600` (100 MB).
+     * Set to `0` to disable the cap (unbounded, the pre-`0.28` behavior). Can also
+     * be set with `PIWI_MAX_STREAM_BUFFER_BYTES`.
+     */
+    maxStreamBufferBytes?: number;
     /**
      * Fail the run when any test was flaky (passed only after a retry). Forwarded
      * to Playwright's native `failOnFlakyTests` config option (Playwright 1.52+)
@@ -237,8 +249,10 @@ declare function createGlobalSetup(options?: PiwiDashboardOptions, userSetup?: (
  *
  * The `globalSetup` field is set to a `string` (or `string[]` if the user
  * already has a global setup) referencing the Piwi global setup module,
- * which registers the run on the server. The original setup path(s) are
- * preserved and executed first.
+ * which registers the run on the server. Piwi's module is chained first so the
+ * run registers before the user's own setup, appearing as "initializing" on the
+ * dashboard while that setup runs; the original setup path(s) are preserved and
+ * executed after it.
  *
  * Playwright options required in `globalSetup` are forwarded via `PIWI_*`
  * environment variables (see `applyOptionsToEnv` in `config.ts` for the
@@ -288,6 +302,12 @@ declare class PiwiDashboardReporter {
     private shardInfo;
     private metadata;
     private enabled;
+    /**
+     * True under `playwright test --list`, where Playwright still constructs this
+     * reporter and fires `onBegin`/`onEnd` but runs no tests. Registering and
+     * finalizing a run would create an empty phantom run and upload an empty report.
+     */
+    private readonly listMode;
     /** True when the server URL and API key came from the desktop app, not from config. */
     private viaDesktopApp;
     private isFullRun;

package/dist/index.js

@@ -82,6 +82,7 @@ var DEFAULTS = {
   streaming: true,
   streamingBatchSize: 5,
   streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
   failOnFlakyTests: false,
   username: null,
   password: null,
@@ -101,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",
@@ -146,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" },
@@ -436,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);
@@ -1187,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\//, "");
 }
@@ -1319,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() {
@@ -1397,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));
@@ -1463,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 = [];
@@ -1489,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() {
@@ -1510,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(
@@ -1603,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();
       }
@@ -1628,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) {
@@ -1646,8 +1808,8 @@ 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;
@@ -1655,7 +1817,7 @@ var StreamManager = class {
         return true;
       },
       (error) => {
-        this.pendingEvents = events.concat(this.pendingEvents);
+        this.pendingEvents.prepend(events);
         this.scheduleRetry(errorMessage(error));
         return false;
       }
@@ -1676,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);
@@ -1728,26 +1890,33 @@ var StreamManager = class {
   }
   /** 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;
     }
     try {
       const MAX_ATTEMPTS = 10;
       for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-        if (this._enabled && this.pendingEvents.length > 0) this.flush();
+        if (this._enabled && !this.pendingEvents.isEmpty) this.flush();
         if (this.flushPromises.length > 0) {
           await Promise.allSettled(this.flushPromises);
           this.flushPromises = [];
         }
-        if (this.pendingEvents.length === 0) {
+        if (this.pendingEvents.isEmpty) {
           const buffered = this.streamBuffer.load();
           if (buffered.length > 0) {
-            this.pendingEvents = buffered;
             this.streamBuffer.clear();
+            this.pendingEvents.prepend(buffered);
             continue;
           }
           return;
@@ -1762,17 +1931,41 @@ var StreamManager = class {
         );
         await new Promise((resolve5) => setTimeout(resolve5, Math.min(1e3 * Math.pow(2, attempt), 1e4)));
       }
-      if (this.pendingEvents.length > 0) {
+      if (!this.pendingEvents.isEmpty) {
+        const remaining = this.pendingEvents.takeAll();
         this.logger.warn(
-          `Could not deliver ${this.pendingEvents.length} live event(s) to the dashboard \u2014 continuing with the end-of-run submit.`
+          `Could not deliver ${remaining.length} live event(s) to the dashboard \u2014 continuing with the end-of-run submit.`
         );
-        this.streamBuffer.append(this.pendingEvents);
-        this.pendingEvents = [];
+        this.streamBuffer.append(remaining);
       }
     } 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.`
+      );
+    }
+  }
   /** 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. */
   scheduleLiveUpload(tc) {
     const hasTrace = !!this.options.uploadTraces && this.fileHandler.findTraceFiles(tc).some((p) => fs8.existsSync(p));
@@ -2190,6 +2383,22 @@ function readSelectionStamp(env = process.env) {
   return { key, version, resolvedHash, resolvedCount };
 }
 
+// src/internal/support/run-mode.ts
+var PW_UI_FLAGS = ["--ui", "--ui-host", "--ui-port"];
+function isUiMode(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_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"));
@@ -2243,15 +2452,6 @@ function isDueForAriaSample(testInfo) {
   return set.has(ariaSampleIdentity(relativeTestFile(testInfo.file), testInfo.title));
 }
 
-// src/internal/support/run-mode.ts
-var PW_UI_FLAGS = ["--ui", "--ui-host", "--ui-port"];
-function isUiMode(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_UI_FLAGS.some((flag) => tok === flag || tok.startsWith(`${flag}=`)));
-}
-
 // src/public/global-setup.ts
 function createGlobalSetup(options, userSetup) {
   return async function globalSetupFn(config) {
@@ -2280,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);
@@ -2429,12 +2634,11 @@ function resolveSetupModule() {
 }
 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;
@@ -2807,7 +3011,7 @@ var RunSubmitter = class {
     }
     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)) {
@@ -3834,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);
@@ -3875,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;
@@ -4156,7 +4365,7 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piwitests/reporter",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Playwright reporter that streams results, traces and HTML reports to a Piwi Dashboard instance",
   "url": "https://github.com/PiwiTests/platform",
   "homepage": "https://piwitests.dev",