@piwitests/reporter 0.4.4 → 0.6.0

package/dist/{crash-recovery.d.ts → internal/streaming/crash-recovery.d.ts}

@@ -1,21 +1,21 @@
-import { HttpClient } from './http-client.js';
-import { Logger } from './logger.js';
+import type { HttpClient } from '../transport/http-client.js';
+import { Logger } from '../support/logger.js';
 /**
  * Persists a test-run payload to disk when all upload strategies fail, so the
  * data can be retried on the next run.
  */
 export declare class CrashRecovery {
-    private filePath;
     private readonly logger;
+    private readonly filePath;
     /**
      * @param projectName Used to derive the temp-file name so recovery data is project-scoped.
      * @param logger      Prefixed logger.
      */
     constructor(projectName: string, logger?: Logger);
     /** Serialise the payload to a temp file for later retry */
-    save(data: Record<string, any>): void;
+    save(data: Record<string, unknown>): void;
     /** Read the saved payload from disk, or return `null` if none exists */
-    load(): Record<string, any> | null;
+    load(): Record<string, unknown> | null;
     /** Delete the recovery file from disk */
     clear(): void;
     /** Attempt to submit a previously saved payload. Clears the recovery file on success. */

package/dist/{crash-recovery.js → internal/streaming/crash-recovery.js}

@@ -34,11 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CrashRecovery = void 0;
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const fs = __importStar(require("fs"));
-const helpers_js_1 = require("./helpers.js");
-const logger_js_1 = require("./logger.js");
+const path = __importStar(require("node:path"));
+const errors_js_1 = require("../support/errors.js");
+const os = __importStar(require("node:os"));
+const fs = __importStar(require("node:fs"));
+const instance_id_js_1 = require("../support/instance-id.js");
+const logger_js_1 = require("../support/logger.js");
 /**
  * Persists a test-run payload to disk when all upload strategies fail, so the
  * data can be retried on the next run.
@@ -50,7 +51,7 @@ class CrashRecovery {
      */
     constructor(projectName, logger = new logger_js_1.Logger()) {
         this.logger = logger;
-        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-recovery-${(0, helpers_js_1.hashForProject)(projectName)}.json`);
+        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-recovery-${(0, instance_id_js_1.hashForProject)(projectName)}.json`);
     }
     /** Serialise the payload to a temp file for later retry */
     save(data) {
@@ -59,7 +60,7 @@ class CrashRecovery {
             this.logger.info('Saved recovery data for later upload');
         }
         catch (error) {
-            this.logger.error(`Failed to save recovery data: ${error.message}`);
+            this.logger.error(`Failed to save recovery data: ${(0, errors_js_1.errorMessage)(error)}`);
         }
     }
     /** Read the saved payload from disk, or return `null` if none exists */
@@ -98,7 +99,7 @@ class CrashRecovery {
             this.clear();
         }
         catch (error) {
-            this.logger.warn(`Could not upload saved test data: ${error.message}`);
+            this.logger.warn(`Could not upload saved test data: ${(0, errors_js_1.errorMessage)(error)}`);
         }
     }
 }

package/dist/{stream-buffer.d.ts → internal/streaming/stream-buffer.d.ts}

@@ -1,10 +1,10 @@
-import type { StreamEvent } from './types.js';
+import type { StreamEvent } from '../../types.js';
 /**
  * Persistent JSONL buffer on disk.  Events are appended to a temp file so they
  * survive a crash and can be replayed when the reporter restarts.
  */
 export declare class StreamBuffer {
-    private filePath;
+    private readonly filePath;
     constructor(projectName: string);
     /** Append one or more events to the on-disk buffer */
     append(events: StreamEvent[]): void;

package/dist/{stream-buffer.js → internal/streaming/stream-buffer.js}

@@ -34,17 +34,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamBuffer = void 0;
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const fs = __importStar(require("fs"));
-const helpers_js_1 = require("./helpers.js");
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const fs = __importStar(require("node:fs"));
+const instance_id_js_1 = require("../support/instance-id.js");
 /**
  * Persistent JSONL buffer on disk.  Events are appended to a temp file so they
  * survive a crash and can be replayed when the reporter restarts.
  */
 class StreamBuffer {
     constructor(projectName) {
-        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-stream-${(0, helpers_js_1.hashForProject)(projectName)}.jsonl`);
+        this.filePath = path.join(os.tmpdir(), `piwi-dashboard-stream-${(0, instance_id_js_1.hashForProject)(projectName)}.jsonl`);
     }
     /** Append one or more events to the on-disk buffer */
     append(events) {

package/dist/{stream-manager.d.ts → internal/streaming/stream-manager.d.ts}

@@ -1,11 +1,11 @@
-import type { PiwiDashboardOptions, ShardInfo } from './config.js';
-import { HttpClient } from './http-client.js';
-import { StreamBuffer } from './stream-buffer.js';
-import { CrashRecovery } from './crash-recovery.js';
-import { Uploader } from './uploader.js';
-import { FileHandler } from './file-handler.js';
-import { Logger } from './logger.js';
-import type { CollectedTestCase, StreamEvent, FilterDetails } from './types.js';
+import type { PiwiDashboardOptions, ShardInfo } from '../../public/options.js';
+import type { HttpClient } from '../transport/http-client.js';
+import type { StreamBuffer } from './stream-buffer.js';
+import type { CrashRecovery } from './crash-recovery.js';
+import type { Uploader } from '../submit/uploader.js';
+import type { FileHandler } from '../files/file-handler.js';
+import { Logger } from '../support/logger.js';
+import type { CollectedTestCase, StreamEvent, FilterDetails } from '../../types.js';
 /**
  * Manages the streaming protocol: queues events (begin / complete), flushes
  * them in batches, schedules retries on failure, and handles per-test-case
@@ -28,6 +28,16 @@ export declare class StreamManager {
     private retryCount;
     private retryTimer;
     private readonly maxRetryDelay;
+    /**
+     * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
+     * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
+     * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
+     * The interval must stay well below the server's stale timeout.
+     */
+    private heartbeatTimer;
+    private heartbeatStopped;
+    private lastActivityAt;
+    private readonly heartbeatInterval;
     /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
     private readonly uploadedCaseFiles;
     private _enabled;
@@ -65,6 +75,10 @@ export declare class StreamManager {
     /** Flush all pending events to the server. Returns a promise that resolves to `true` on success or `false` on failure (events are re-queued for retry). */
     flush(): Promise<boolean> | null;
     private scheduleRetry;
+    private scheduleHeartbeat;
+    private sendHeartbeat;
+    /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
+    private stopHeartbeat;
     /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
     drain(): Promise<void>;
     /** 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. */

package/dist/{stream-manager.js → internal/streaming/stream-manager.js}

@@ -34,9 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamManager = void 0;
-const fs = __importStar(require("fs"));
-const logger_js_1 = require("./logger.js");
-const helpers_js_1 = require("./helpers.js");
+const fs = __importStar(require("node:fs"));
+const errors_js_1 = require("../support/errors.js");
+const http_client_js_1 = require("../transport/http-client.js");
+const logger_js_1 = require("../support/logger.js");
+const limiter_js_1 = require("../support/limiter.js");
+const setup_file_js_1 = require("../support/setup-file.js");
 /**
  * Manages the streaming protocol: queues events (begin / complete), flushes
  * them in batches, schedules retries on failure, and handles per-test-case
@@ -85,10 +88,20 @@ class StreamManager {
         this.flushTimer = null;
         this.flushPromises = [];
         this.liveUploadPromises = [];
-        this.limitLiveUpload = (0, helpers_js_1.createLimiter)(2);
+        this.limitLiveUpload = (0, limiter_js_1.createLimiter)(2);
         this.retryCount = 0;
         this.retryTimer = null;
         this.maxRetryDelay = 30000;
+        /**
+         * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
+         * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
+         * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
+         * The interval must stay well below the server's stale timeout.
+         */
+        this.heartbeatTimer = null;
+        this.heartbeatStopped = false;
+        this.lastActivityAt = 0;
+        this.heartbeatInterval = 15000;
         /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
         this.uploadedCaseFiles = new WeakSet();
         this._enabled = false;
@@ -102,7 +115,7 @@ class StreamManager {
         this._startPromise = this._doStart(startTime, metadata, instanceId, playwrightVersion, shardInfo, isFullRun, filterDetails);
     }
     async _doStart(startTime, metadata, instanceId, playwrightVersion, shardInfo, isFullRun, filterDetails) {
-        const setupInfo = (0, helpers_js_1.readSetupInfo)(this.options.projectName);
+        const setupInfo = (0, setup_file_js_1.readSetupInfo)(this.options.projectName);
         try {
             this._auth = await this.httpClient.resolveAuth(this.options);
             await this.recovery.tryUpload(this.httpClient, this._auth);
@@ -122,11 +135,11 @@ class StreamManager {
                         filterDetails,
                     }, this._auth);
                 }
-                catch (beginError) {
+                catch (error) {
                     // Stale setupInfo — the run was cancelled (e.g. by crash recovery submit).
                     // Fall back to creating a fresh run instead of silently disabling streaming.
-                    if (!beginError.message?.includes('409'))
-                        throw beginError;
+                    if (!(error instanceof http_client_js_1.HttpError && error.status === 409))
+                        throw error;
                     this.logger.debug(`Setup info expired, creating fresh run...`);
                     response = await this.httpClient.postJSON('/api/test-runs/start', {
                         projectName: this.options.projectName,
@@ -165,6 +178,8 @@ class StreamManager {
                 this._token = response.streamToken;
                 this._enabled = true;
                 this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
+                this.lastActivityAt = Date.now();
+                this.scheduleHeartbeat();
                 if (this.pendingBeginEvents.length > 0) {
                     this.pendingEvents = [...this.pendingBeginEvents, ...this.pendingEvents];
                     this.pendingBeginEvents = [];
@@ -173,7 +188,7 @@ class StreamManager {
             }
         }
         catch (error) {
-            this.logger.debug(`Streaming not available: ${error.message}. Will use batch mode.`);
+            this.logger.debug(`Streaming not available: ${(0, errors_js_1.errorMessage)(error)}. Will use batch mode.`);
             this._enabled = false;
         }
     }
@@ -213,6 +228,7 @@ class StreamManager {
             .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);
@@ -239,8 +255,46 @@ class StreamManager {
                 this.flush();
         }, delay);
     }
+    // Schedule the next idle heartbeat. Self-rescheduling; cleared by stopHeartbeat.
+    scheduleHeartbeat() {
+        if (this.heartbeatStopped || this.heartbeatTimer)
+            return;
+        this.heartbeatTimer = setTimeout(() => {
+            this.heartbeatTimer = null;
+            void this.sendHeartbeat();
+        }, this.heartbeatInterval);
+    }
+    // Ping the server only when the run has actually been idle. Real event traffic
+    // already bumps the server's activity timestamp, so a recent flush (or pending
+    // events about to flush) makes the ping redundant — skip it and reschedule.
+    async sendHeartbeat() {
+        if (this.heartbeatStopped || !this._enabled || !this._runId || !this._token)
+            return;
+        const idleFor = Date.now() - this.lastActivityAt;
+        if (idleFor < this.heartbeatInterval || this.pendingEvents.length > 0) {
+            this.scheduleHeartbeat();
+            return;
+        }
+        try {
+            await this.httpClient.postJSON(`/api/test-runs/${this._runId}/heartbeat`, { streamToken: this._token }, this._auth);
+            this.lastActivityAt = Date.now();
+        }
+        catch (error) {
+            this.logger.debug(`Heartbeat failed: ${(0, errors_js_1.errorMessage)(error)}`);
+        }
+        this.scheduleHeartbeat();
+    }
+    /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
+    stopHeartbeat() {
+        this.heartbeatStopped = true;
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
     /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
     async drain() {
+        this.stopHeartbeat();
         if (!this._enabled) {
             this.pendingEvents = [];
             this.flushPromises = [];
@@ -303,9 +357,9 @@ class StreamManager {
                     return;
                 }
                 catch (error) {
-                    const retryable = error.message?.includes('404');
+                    const retryable = error instanceof http_client_js_1.HttpError && error.status === 404;
                     if (!retryable || attempt === delays.length - 1) {
-                        this.logger.debug(`Live file upload failed for "${tc.title}": ${error.message}`);
+                        this.logger.debug(`Live file upload failed for "${tc.title}": ${(0, errors_js_1.errorMessage)(error)}`);
                         return; // The end-of-run pass retries cases that failed here
                     }
                 }
@@ -330,7 +384,7 @@ class StreamManager {
                     this.uploadedCaseFiles.add(tc);
             }
             catch (error) {
-                this.logger.warn(`Failed to upload files for "${tc.title}": ${error.message}`);
+                this.logger.warn(`Failed to upload files for "${tc.title}": ${(0, errors_js_1.errorMessage)(error)}`);
             }
         }
     }

package/dist/{run-submitter.d.ts → internal/submit/run-submitter.d.ts}

@@ -1,11 +1,11 @@
 import type { FullResult } from '@playwright/test/reporter';
-import type { PiwiDashboardOptions, ShardInfo } from './config.js';
-import { HttpClient } from './http-client.js';
-import { Uploader } from './uploader.js';
-import { CrashRecovery } from './crash-recovery.js';
-import { StreamManager } from './stream-manager.js';
-import { Logger } from './logger.js';
-import type { CollectedTestCase, SetupStep, FilterDetails } from './types.js';
+import type { PiwiDashboardOptions, ShardInfo } from '../../public/options.js';
+import type { HttpClient } from '../transport/http-client.js';
+import type { Uploader } from './uploader.js';
+import type { CrashRecovery } from '../streaming/crash-recovery.js';
+import type { StreamManager } from '../streaming/stream-manager.js';
+import { Logger } from '../support/logger.js';
+import type { CollectedTestCase, SetupStep, FilterDetails } from '../../types.js';
 /**
  * Snapshot of everything the reporter has collected by `onEnd`, handed off to
  * the `RunSubmitter` so the reporter itself stays a thin collect-and-hand-off

package/dist/{run-submitter.js → internal/submit/run-submitter.js}

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunSubmitter = void 0;
-const logger_js_1 = require("./logger.js");
-const step_analyzer_js_1 = require("./step-analyzer.js");
+const errors_js_1 = require("../support/errors.js");
+const http_client_js_1 = require("../transport/http-client.js");
+const logger_js_1 = require("../support/logger.js");
+const step_analyzer_js_1 = require("../collect/step-analyzer.js");
 const serializer_js_1 = require("./serializer.js");
 /**
  * Owns the three-tier submit/fallback ladder:
@@ -54,7 +56,7 @@ class RunSubmitter {
             auth = sm?.auth ?? (await this.httpClient.resolveAuth(run.options));
         }
         catch (error) {
-            this.logger.error(`Authentication failed: ${error.message}`);
+            this.logger.error(`Authentication failed: ${(0, errors_js_1.errorMessage)(error)}`);
             throw error;
         }
         if (sm?.enabled && sm?.runId != null) {
@@ -87,6 +89,7 @@ class RunSubmitter {
             totalTests: run.totalTests,
             passedTests: run.passedTests,
             failedTests: run.failedTests,
+            timedOutTests: run.timedOutTests,
             skippedTests: run.skippedTests,
             didNotRunTests: run.didNotRunTests,
             environment: run.options.environment,
@@ -114,6 +117,7 @@ class RunSubmitter {
                 totalTests: run.totalTests,
                 passedTests: run.passedTests,
                 failedTests: run.failedTests,
+                timedOutTests: run.timedOutTests,
                 skippedTests: run.skippedTests,
                 didNotRunTests: run.didNotRunTests,
                 flakyTests,
@@ -138,13 +142,13 @@ class RunSubmitter {
                     await this.uploader.uploadReportsForStreamingRun(run.options.projectName, sm.runId, this.reportOptions(run), run.startTime, auth);
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to upload reports for streaming run: ${error.message}`);
+                    this.logger.warn(`Failed to upload reports for streaming run: ${(0, errors_js_1.errorMessage)(error)}`);
                 }
             }
             return true;
         }
         catch (error) {
-            this.logger.warn(`Failed to finalize streaming run: ${error.message}`);
+            this.logger.warn(`Failed to finalize streaming run: ${(0, errors_js_1.errorMessage)(error)}`);
             this.logger.info('Falling back to batch upload...');
             return false;
         }
@@ -156,9 +160,9 @@ class RunSubmitter {
             return true;
         }
         catch (error) {
-            if (error.message?.includes('401') && !auth)
+            if (error instanceof http_client_js_1.HttpError && error.status === 401 && !auth)
                 throw error;
-            this.logger.warn(`Failed to upload with files: ${error.message}`);
+            this.logger.warn(`Failed to upload with files: ${(0, errors_js_1.errorMessage)(error)}`);
             this.logger.info('Falling back to JSON upload...');
             return false;
         }
@@ -172,9 +176,9 @@ class RunSubmitter {
         catch (error) {
             // If the server returned 401 and no auth was configured, this is a
             // configuration error — throw so the caller knows it's fatal.
-            if (error.message?.includes('401') && !auth)
+            if (error instanceof http_client_js_1.HttpError && error.status === 401 && !auth)
                 throw error;
-            this.logger.error(`All upload methods failed: ${error.message}`);
+            this.logger.error(`All upload methods failed: ${(0, errors_js_1.errorMessage)(error)}`);
             // Save the wire-serialized form so the recovery file matches the
             // original submit payload (no raw attachments / internal fields).
             this.recovery.save((0, serializer_js_1.serializeRun)(payload, { includeTestCases: true }));

package/dist/{serializer.d.ts → internal/submit/serializer.d.ts}

@@ -1,5 +1,5 @@
 import type { FullResult } from '@playwright/test/reporter';
-import type { CollectedTestCase, WireTestCase } from './types.js';
+import type { CollectedTestCase, WireTestCase } from '../../types.js';
 import type { RunPayload } from './uploader.js';
 /**
  * Resolve the overall Piwi run status from Playwright's `FullResult.status`

package/dist/{serializer.js → internal/submit/serializer.js}

@@ -64,6 +64,7 @@ function toWireTestCase(tc) {
         suitePath: rest.suitePath ?? null,
         suiteConfig: rest.suiteConfig ?? null,
         testAnnotations: rest.testAnnotations ?? null,
+        locatorSnapshots: rest.locatorSnapshots || null,
     };
 }
 /**
@@ -85,6 +86,7 @@ function serializeRun(payload, opts) {
         totalTests: payload.totalTests,
         passedTests: payload.passedTests,
         failedTests: payload.failedTests,
+        timedOutTests: payload.timedOutTests ?? 0,
         skippedTests: payload.skippedTests,
         didNotRunTests: payload.didNotRunTests ?? 0,
         environment: payload.environment ?? null,

package/dist/{uploader.d.ts → internal/submit/uploader.d.ts}

@@ -1,7 +1,7 @@
-import { HttpClient } from './http-client.js';
-import { FileHandler } from './file-handler.js';
-import { Logger } from './logger.js';
-import type { CollectedTestCase, FilterDetails } from './types.js';
+import type { HttpClient } from '../transport/http-client.js';
+import type { FileHandler } from '../files/file-handler.js';
+import { Logger } from '../support/logger.js';
+import type { CollectedTestCase, FilterDetails } from '../../types.js';
 /** Payload for a batch test-run submission */
 export interface RunPayload {
     /** Name of the project the run belongs to */
@@ -17,6 +17,7 @@ export interface RunPayload {
     totalTests: number;
     passedTests: number;
     failedTests: number;
+    timedOutTests?: number;
     skippedTests: number;
     /** Tests that never executed (cut short by `maxFailures` or a serial-group failure) */
     didNotRunTests?: number;
@@ -60,15 +61,15 @@ export interface ReportOptions {
  * uploads for already-submitted streaming runs.
  */
 export declare class Uploader {
-    private httpClient;
-    private fileHandler;
-    private logger;
+    private readonly httpClient;
+    private readonly fileHandler;
+    private readonly logger;
     /**
      * @param httpClient  HTTP client for server communication.
      * @param fileHandler File discovery and compression helper.
      * @param logger      Prefixed logger.
      */
-    constructor(httpClient: HttpClient, fileHandler: FileHandler, logger: Logger);
+    constructor(httpClient: HttpClient, fileHandler: FileHandler, logger?: Logger);
     /** Submit test results as a plain JSON payload (no file attachments) */
     uploadJSON(payload: RunPayload, auth: string | null): Promise<any>;
     /** Submit test results as a multipart form with trace files and compressed report directories */

package/dist/{uploader.js → internal/submit/uploader.js}

@@ -1,12 +1,47 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uploader = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const form_data_1 = __importDefault(require("form-data"));
+const http_client_js_1 = require("../transport/http-client.js");
+const logger_js_1 = require("../support/logger.js");
 const serializer_js_1 = require("./serializer.js");
 /**
  * Handles all upload strategies: plain JSON, multipart (with reports and
@@ -19,7 +54,7 @@ class Uploader {
      * @param fileHandler File discovery and compression helper.
      * @param logger      Prefixed logger.
      */
-    constructor(httpClient, fileHandler, logger) {
+    constructor(httpClient, fileHandler, logger = new logger_js_1.Logger()) {
         this.httpClient = httpClient;
         this.fileHandler = fileHandler;
         this.logger = logger;
@@ -104,15 +139,15 @@ class Uploader {
             if (traceInfo) {
                 form.append('trace_hash', traceInfo.hash);
                 if (includeTraceFile) {
-                    form.append('trace', fs_1.default.createReadStream(traceInfo.tracePath), {
-                        filename: path_1.default.basename(traceInfo.tracePath),
+                    form.append('trace', fs.createReadStream(traceInfo.tracePath), {
+                        filename: path.basename(traceInfo.tracePath),
                     });
                 }
             }
             if (attachments.length > 0) {
                 form.append('attach_meta', JSON.stringify(attachments.map((a) => ({ name: a.name, contentType: a.contentType, originalName: a.originalName }))));
                 for (const a of attachments) {
-                    form.append('attach_file', fs_1.default.createReadStream(a.path), { filename: a.originalName });
+                    form.append('attach_file', fs.createReadStream(a.path), { filename: a.originalName });
                 }
             }
             return form;
@@ -123,7 +158,7 @@ class Uploader {
         }
         catch (error) {
             // 422: the server doesn't have the blob after all — resend with the file
-            if (traceInfo && !includeTraceFile && error.message?.includes('422')) {
+            if (traceInfo && !includeTraceFile && error instanceof http_client_js_1.HttpError && error.status === 422) {
                 await this.httpClient.postFormData(`/api/test-runs/${runId}/case-files`, buildForm(true), auth);
             }
             else {
@@ -168,7 +203,7 @@ class Uploader {
                 originalName: a.originalName,
             }))));
             for (const a of attachments) {
-                form.append(`attach_file_${i}`, fs_1.default.createReadStream(a.path), { filename: a.originalName });
+                form.append(`attach_file_${i}`, fs.createReadStream(a.path), { filename: a.originalName });
                 attachmentCount++;
             }
         }
@@ -179,8 +214,8 @@ class Uploader {
         let traceCount = 0;
         for (const [i, tc] of testCases.entries()) {
             for (const tp of this.fileHandler.findTraceFiles(tc)) {
-                if (fs_1.default.existsSync(tp)) {
-                    form.append(`trace_${i}`, fs_1.default.createReadStream(tp), { filename: path_1.default.basename(tp) });
+                if (fs.existsSync(tp)) {
+                    form.append(`trace_${i}`, fs.createReadStream(tp), { filename: path.basename(tp) });
                     traceCount++;
                 }
             }

package/dist/internal/support/ci.d.ts

@@ -0,0 +1,2 @@
+/** Detect a stable CI run label from well-known environment variables. Returns null outside CI. */
+export declare function detectCiRunLabel(): string | null;

package/dist/internal/support/ci.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCiRunLabel = detectCiRunLabel;
+/** Detect a stable CI run label from well-known environment variables. Returns null outside CI. */
+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;
+    return null;
+}

package/dist/internal/support/cli-filters.d.ts

@@ -0,0 +1 @@
+export declare function detectCliFileFilters(argv?: string[]): string[];