@piwitests/reporter 0.5.0 → 0.7.0

package/dist/internal/files/compression.js

@@ -0,0 +1,69 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressDirectory = compressDirectory;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zlib = __importStar(require("node:zlib"));
+const node_util_1 = require("node:util");
+const gzipAsync = (0, node_util_1.promisify)(zlib.gzip);
+/**
+ * Recursively read a directory and pack all files into a gzip-compressed
+ * archive (a concatenation of length-prefixed path+content pairs).
+ */
+async function compressDirectory(sourceDir) {
+    const files = [];
+    function collect(dir, baseDir = '') {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            const rel = path.join(baseDir, entry.name);
+            if (entry.isDirectory())
+                collect(full, rel);
+            else if (entry.isFile())
+                files.push({ path: rel, content: fs.readFileSync(full) });
+        }
+    }
+    collect(sourceDir);
+    const parts = [];
+    for (const f of files) {
+        const pb = Buffer.from(f.path, 'utf8');
+        const plb = Buffer.allocUnsafe(4);
+        plb.writeUInt32LE(pb.length, 0);
+        const clb = Buffer.allocUnsafe(4);
+        clb.writeUInt32LE(f.content.length, 0);
+        parts.push(plb, pb, clb, f.content);
+    }
+    return await gzipAsync(Buffer.concat(parts), { level: 5 });
+}

package/dist/{file-handler.d.ts → internal/files/file-handler.d.ts}

@@ -1,5 +1,5 @@
-import { Logger } from './logger.js';
-import type { CollectedTestCase, RawAttachment, TraceHashInfo } from './types.js';
+import { Logger } from '../support/logger.js';
+import type { CollectedTestCase, RawAttachment, TraceHashInfo } from '../../types.js';
 /**
  * File-system helpers for discovering report directories, trace files, and
  * test attachments, as well as compressing report directories and computing
@@ -16,7 +16,7 @@ export declare class FileHandler {
     compressReportDirectory(reportDir: string): Promise<Buffer | null>;
     /** Return resolved paths for all trace attachments on a test case */
     findTraceFiles(testCase: CollectedTestCase): string[];
-    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-dashboard-*` attachments. */
+    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-*` attachments. */
     findAllAttachments(testCase: CollectedTestCase): Array<{
         name: string;
         path: string;
@@ -25,7 +25,7 @@ export declare class FileHandler {
     }>;
     /** Mapping of well-known report type names to their default output directories */
     getDefaultReportDirs(): Record<string, string>;
-    /** Parse Piwi-internal attachment bodies (`piwi-dashboard-network`, `-web-vitals`, `-console`, `-aria-snapshot`) into structured fields on the test case */
+    /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`) into structured fields on the test case */
     parsePerformanceAttachments(testCase: CollectedTestCase, attachments: RawAttachment[]): void;
     /** Compute SHA-256 hash and size for a single test case's trace file. Returns `null` when the case has no trace on disk. */
     computeSingleTraceHash(testCase: CollectedTestCase): Promise<TraceHashInfo | null>;

package/dist/{file-handler.js → internal/files/file-handler.js}

@@ -1,14 +1,46 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileHandler = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const crypto_1 = __importDefault(require("crypto"));
+const fs = __importStar(require("node:fs"));
+const errors_js_1 = require("../support/errors.js");
+const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
 const compression_js_1 = require("./compression.js");
-const logger_js_1 = require("./logger.js");
+const logger_js_1 = require("../support/logger.js");
+const attachments_js_1 = require("../capture/attachments.js");
 /**
  * File-system helpers for discovering report directories, trace files, and
  * test attachments, as well as compressing report directories and computing
@@ -21,11 +53,11 @@ class FileHandler {
     /** Locate a Playwright HTML report directory containing `index.html`. Optionally override the search path. */
     findHTMLReportDirectory(customDir) {
         const possibleDirs = customDir
-            ? [customDir, path_1.default.join(process.cwd(), customDir)]
-            : ['playwright-report', './playwright-report', path_1.default.join(process.cwd(), 'playwright-report')];
+            ? [customDir, path.join(process.cwd(), customDir)]
+            : ['playwright-report', './playwright-report', path.join(process.cwd(), 'playwright-report')];
         for (const reportDir of possibleDirs) {
-            if (fs_1.default.existsSync(reportDir) && fs_1.default.statSync(reportDir).isDirectory()) {
-                if (fs_1.default.existsSync(path_1.default.join(reportDir, 'index.html')))
+            if (fs.existsSync(reportDir) && fs.statSync(reportDir).isDirectory()) {
+                if (fs.existsSync(path.join(reportDir, 'index.html')))
                     return reportDir;
             }
         }
@@ -33,9 +65,9 @@ class FileHandler {
     }
     /** Check if `dir` exists and is a directory; also checks `path.join(process.cwd(), dir)` */
     findReportDirectory(dir) {
-        const candidates = [dir, path_1.default.join(process.cwd(), dir)];
+        const candidates = [dir, path.join(process.cwd(), dir)];
         for (const candidate of candidates) {
-            if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isDirectory())
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory())
                 return candidate;
         }
         return null;
@@ -46,7 +78,7 @@ class FileHandler {
             return (await (0, compression_js_1.compressDirectory)(reportDir)) || null;
         }
         catch (error) {
-            this.logger.warn(`Failed to compress report directory ${reportDir}: ${error.message}`);
+            this.logger.warn(`Failed to compress report directory ${reportDir}: ${(0, errors_js_1.errorMessage)(error)}`);
             return null;
         }
     }
@@ -56,26 +88,26 @@ class FileHandler {
         if (testCase.attachments) {
             for (const a of testCase.attachments) {
                 if (a.name === 'trace' && a.path)
-                    set.add(path_1.default.resolve(a.path));
+                    set.add(path.resolve(a.path));
             }
         }
         return Array.from(set);
     }
-    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-dashboard-*` attachments. */
+    /** Return all non-trace, non-internal attachments from a test case. Skips `trace` and `piwi-*` attachments. */
     findAllAttachments(testCase) {
         const result = [];
         if (testCase.attachments) {
             for (const a of testCase.attachments) {
                 if (a.name === 'trace')
                     continue;
-                if (a.name?.startsWith('piwi-dashboard-'))
+                if (a.name && attachments_js_1.INTERNAL_ATTACHMENT_NAMES.has(a.name))
                     continue;
-                if (a.path && fs_1.default.existsSync(a.path)) {
+                if (a.path && fs.existsSync(a.path)) {
                     result.push({
                         name: a.name || 'attachment',
-                        path: path_1.default.resolve(a.path),
+                        path: path.resolve(a.path),
                         contentType: a.contentType || 'application/octet-stream',
-                        originalName: path_1.default.basename(a.path),
+                        originalName: path.basename(a.path),
                     });
                 }
             }
@@ -91,10 +123,10 @@ class FileHandler {
             blob: 'blob-report',
         };
     }
-    /** Parse Piwi-internal attachment bodies (`piwi-dashboard-network`, `-web-vitals`, `-console`, `-aria-snapshot`) into structured fields on the test case */
+    /** Parse Piwi-internal attachment bodies (`piwi-network`, `piwi-web-vitals`, `piwi-console`, `piwi-aria-snapshot`) into structured fields on the test case */
     parsePerformanceAttachments(testCase, attachments) {
         const find = (name) => attachments.find((a) => a.name === name);
-        const net = find('piwi-dashboard-network');
+        const net = find(attachments_js_1.ATTACHMENT_NAMES.network);
         if (net?.body) {
             try {
                 testCase.networkRequests = JSON.parse(net.body.toString());
@@ -103,7 +135,7 @@ class FileHandler {
                 /* ignore */
             }
         }
-        const vitals = find('piwi-dashboard-web-vitals');
+        const vitals = find(attachments_js_1.ATTACHMENT_NAMES.webVitals);
         if (vitals?.body) {
             try {
                 testCase.webVitals = JSON.parse(vitals.body.toString());
@@ -112,7 +144,7 @@ class FileHandler {
                 /* ignore */
             }
         }
-        const consoleLog = find('piwi-dashboard-console');
+        const consoleLog = find(attachments_js_1.ATTACHMENT_NAMES.console);
         if (consoleLog?.body) {
             try {
                 testCase.consoleLogs = JSON.parse(consoleLog.body.toString());
@@ -121,7 +153,7 @@ class FileHandler {
                 /* ignore */
             }
         }
-        const aria = find('piwi-dashboard-aria-snapshot');
+        const aria = find(attachments_js_1.ATTACHMENT_NAMES.ariaSnapshot);
         if (aria?.body)
             testCase.ariaSnapshot = aria.body.toString();
     }
@@ -130,14 +162,14 @@ class FileHandler {
         const tracePaths = this.findTraceFiles(testCase);
         let lastPath = null;
         for (const tp of tracePaths) {
-            if (fs_1.default.existsSync(tp))
+            if (fs.existsSync(tp))
                 lastPath = tp;
         }
         if (!lastPath)
             return null;
-        const hash = crypto_1.default.createHash('sha256');
+        const hash = crypto.createHash('sha256');
         await new Promise((resolve, reject) => {
-            fs_1.default.createReadStream(lastPath)
+            fs.createReadStream(lastPath)
                 .on('data', (chunk) => hash.update(chunk))
                 .on('end', resolve)
                 .on('error', reject);
@@ -145,7 +177,7 @@ class FileHandler {
         return {
             tracePath: lastPath,
             hash: hash.digest('hex'),
-            size: fs_1.default.statSync(lastPath).size,
+            size: fs.statSync(lastPath).size,
         };
     }
     /** Ask the server which trace hashes it already has, returning the set of hashes that are missing */

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

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,7 +88,7 @@ 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;
@@ -112,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);
@@ -132,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,
@@ -185,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;
         }
     }
@@ -277,7 +280,7 @@ class StreamManager {
             this.lastActivityAt = Date.now();
         }
         catch (error) {
-            this.logger.debug(`Heartbeat failed: ${error.message}`);
+            this.logger.debug(`Heartbeat failed: ${(0, errors_js_1.errorMessage)(error)}`);
         }
         this.scheduleHeartbeat();
     }
@@ -354,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
                     }
                 }
@@ -381,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) {
@@ -140,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;
         }
@@ -158,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;
         }
@@ -174,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/{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 */
@@ -61,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 */