@piwitests/reporter 0.5.0 → 0.6.0

package/dist/{metadata-collector.js → internal/collect/metadata-collector.js}

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataCollector = void 0;
-const child_process_1 = require("child_process");
-const logger_js_1 = require("./logger.js");
+const node_child_process_1 = require("node:child_process");
+const errors_js_1 = require("../support/errors.js");
+const logger_js_1 = require("../support/logger.js");
 /**
  * Collects CI/CD environment metadata, SCM (git) information, and Playwright
  * config metadata to attach to each test run submission.
@@ -47,7 +48,7 @@ class MetadataCollector {
             const all = suite.allTests();
             if (all.length > 0) {
                 const first = all[0];
-                if (first?.parent?.project) {
+                if (first?.parent) {
                     const proj = first.parent.project();
                     if (proj?.metadata)
                         metadata.playwrightProject = proj.metadata;
@@ -146,23 +147,25 @@ class MetadataCollector {
         const scm = {};
         try {
             const execOpts = { encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024 };
-            scm.commit = (0, child_process_1.execSync)('git rev-parse HEAD', execOpts).trim();
-            scm.branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', execOpts).trim();
-            scm.author = (0, child_process_1.execSync)('git log -1 --pretty=format:"%an"', execOpts).trim();
-            scm.commitMessage = (0, child_process_1.execSync)('git log -1 --pretty=format:"%s"', execOpts).trim();
+            scm.commit = (0, node_child_process_1.execSync)('git rev-parse HEAD', execOpts).trim();
+            scm.branch = (0, node_child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', execOpts).trim();
+            scm.author = (0, node_child_process_1.execSync)('git log -1 --pretty=format:"%an"', execOpts).trim();
+            scm.commitMessage = (0, node_child_process_1.execSync)('git log -1 --pretty=format:"%s"', execOpts).trim();
             try {
-                scm.remoteUrl = (0, child_process_1.execSync)('git config --get remote.origin.url', execOpts).trim();
+                scm.remoteUrl = (0, node_child_process_1.execSync)('git config --get remote.origin.url', execOpts).trim();
             }
             catch {
                 /* optional */
             }
         }
         catch (error) {
-            this.logger.debug(`Git info not available: ${error.message}`);
+            this.logger.debug(`Git info not available: ${(0, errors_js_1.errorMessage)(error)}`);
         }
         return Object.keys(scm).length > 0 ? scm : undefined;
     }
     collectCiInfo() {
+        // Env vars are `string | undefined`; undefined values are dropped on JSON
+        // serialization, so collecting them directly preserves the prior behavior.
         const ci = {};
         const env = process.env;
         if (env.JENKINS_URL) {

package/dist/{skip-classify.d.ts → internal/collect/skip-classify.d.ts}

@@ -1,4 +1,4 @@
-import type { TestAnnotation } from './types.js';
+import type { TestAnnotation } from '../../types.js';
 /** Minimal structural shape for the annotation carriers (avoids importing Playwright types). */
 interface AnnotationCarrier {
     annotations?: ReadonlyArray<{

package/dist/{step-analyzer.d.ts → internal/collect/step-analyzer.d.ts}

@@ -14,6 +14,12 @@ export interface FlatStep {
     title: string;
     duration: number;
     category: string;
+    /** Error message when the step failed (undefined when the step passed). */
+    error?: {
+        message: string;
+    };
+    /** True when the step carried an error — the signal the server needs for inline failure markers. */
+    failed?: boolean;
 }
 /** Step-event category restricted to the values `extractTestStepEvents` emits. */
 export type StepEventCategory = 'hook' | 'fixture' | 'test.step' | 'expect' | 'wait';

package/dist/{step-analyzer.js → internal/collect/step-analyzer.js}

@@ -84,11 +84,16 @@ function categorizeStep(title, pwCategory) {
 function flattenSteps(steps) {
     const result = [];
     for (const step of steps) {
-        result.push({
+        const flat = {
             title: step.title,
             duration: step.duration,
             category: categorizeStep(step.title, step.category),
-        });
+        };
+        if (step.error?.message) {
+            flat.error = { message: step.error.message };
+            flat.failed = true;
+        }
+        result.push(flat);
         if (step.steps?.length > 0)
             result.push(...flattenSteps(step.steps));
     }

package/dist/internal/config/env.d.ts

@@ -0,0 +1,45 @@
+import type { PiwiDashboardOptions } from '../../public/options.js';
+/**
+ * Single source of truth for the `PIWI_*` env-var → option mapping. Both
+ * `resolveOptions` (env → option) and `applyOptionsToEnv` (option → env, used
+ * by `wrapConfig` to bridge into the global-setup process) read these names so
+ * the mapping lives in exactly one place.
+ */
+export declare const PIWI_ENV_KEYS: {
+    readonly serverUrl: "PIWI_DASHBOARD_URL";
+    readonly projectName: "PIWI_PROJECT_NAME";
+    readonly verbose: "PIWI_VERBOSE";
+    readonly apiKey: "PIWI_API_KEY";
+    readonly username: "PIWI_USERNAME";
+    readonly password: "PIWI_PASSWORD";
+    readonly environment: "PIWI_ENVIRONMENT";
+    readonly label: "PIWI_LABEL";
+    readonly runLabel: "PIWI_RUN_LABEL";
+    readonly streaming: "PIWI_STREAMING";
+    readonly streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE";
+    readonly streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY";
+    readonly liveFileUploads: "PIWI_LIVE_FILE_UPLOADS";
+    readonly uploadTraces: "PIWI_UPLOAD_TRACES";
+    readonly uploadReport: "PIWI_UPLOAD_REPORT";
+    readonly captureLocators: "PIWI_CAPTURE_LOCATORS";
+};
+/**
+ * Merge raw user options with defaults, reading from `PIWI_*` env vars when
+ * options are not provided.
+ *
+ * Env semantics: env vars fill in values the caller didn't provide (fallback).
+ * They're applied to `raw` *before* the `DEFAULTS` merge so a built-in default
+ * never masks an env var (`PIWI_PROJECT_NAME` would otherwise be masked by the
+ * `default-project` default).
+ *
+ * One preserved quirk: `PIWI_VERBOSE` wins over both the default *and* an
+ * explicit user option.
+ */
+export declare function resolveOptions(raw: Record<string, any>): PiwiDashboardOptions;
+/**
+ * Write the options that the isolated `global-setup-module` process needs into
+ * `PIWI_*` env vars. `wrapConfig` calls this so the global setup (which runs
+ * `resolveOptions({})` in a separate module) picks up the same server/auth
+ * config the reporter instance uses. Only writes values that are actually set.
+ */
+export declare function applyOptionsToEnv(options: PiwiDashboardOptions): void;

package/dist/{config.js → internal/config/env.js}

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PIWI_ENV_KEYS = void 0;
 exports.resolveOptions = resolveOptions;
 exports.applyOptionsToEnv = applyOptionsToEnv;
+/**
+ * Built-in option defaults, merged *under* any user-provided or env-derived
+ * value (see `resolveOptions`).
+ */
 const DEFAULTS = {
     projectName: 'default-project',
     uploadTraces: true,
@@ -49,53 +53,64 @@ function readBool(val) {
         return undefined;
     return val === 'true';
 }
+/**
+ * Declarative env → option fallback table. `resolveOptions` walks this instead
+ * of repeating ~15 near-identical merge lines, so adding an env-backed option
+ * means adding one row.
+ *
+ * Guard semantics (preserved from the original hand-written merges):
+ *  - `string` / `number`: a *truthy* env value fills the option, so an empty
+ *    string is ignored.
+ *  - `bool`: any *defined* env value fills it (via `readBool`), so
+ *    `PIWI_STREAMING=false` actually disables streaming.
+ *
+ * `verbose` is intentionally absent — it *overrides* rather than falls back, and
+ * is applied after the `DEFAULTS` merge in `resolveOptions`.
+ */
+const ENV_FALLBACK_SPECS = [
+    { option: 'serverUrl', env: exports.PIWI_ENV_KEYS.serverUrl, kind: 'string' },
+    { option: 'projectName', env: exports.PIWI_ENV_KEYS.projectName, kind: 'string' },
+    { option: 'apiKey', env: exports.PIWI_ENV_KEYS.apiKey, kind: 'string' },
+    { option: 'username', env: exports.PIWI_ENV_KEYS.username, kind: 'string' },
+    { option: 'password', env: exports.PIWI_ENV_KEYS.password, kind: 'string' },
+    { option: 'environment', env: exports.PIWI_ENV_KEYS.environment, kind: 'string' },
+    { option: 'label', env: exports.PIWI_ENV_KEYS.label, kind: 'string' },
+    { option: 'runLabel', env: exports.PIWI_ENV_KEYS.runLabel, kind: 'string' },
+    { option: 'streaming', env: exports.PIWI_ENV_KEYS.streaming, kind: 'bool' },
+    { option: 'streamingBatchSize', env: exports.PIWI_ENV_KEYS.streamingBatchSize, kind: 'number' },
+    { option: 'streamingBatchDelay', env: exports.PIWI_ENV_KEYS.streamingBatchDelay, kind: 'number' },
+    { option: 'liveFileUploads', env: exports.PIWI_ENV_KEYS.liveFileUploads, kind: 'bool' },
+    { option: 'uploadTraces', env: exports.PIWI_ENV_KEYS.uploadTraces, kind: 'bool' },
+    { option: 'uploadReport', env: exports.PIWI_ENV_KEYS.uploadReport, kind: 'bool' },
+    { option: 'captureLocators', env: exports.PIWI_ENV_KEYS.captureLocators, kind: 'bool' },
+];
 /**
  * Merge raw user options with defaults, reading from `PIWI_*` env vars when
  * options are not provided.
  *
  * Env semantics: env vars fill in values the caller didn't provide (fallback).
  * They're applied to `raw` *before* the `DEFAULTS` merge so a built-in default
- * never masks an env var (the pre-Phase-4 `PIWI_PROJECT_NAME` was masked by the
- * `default-project` default — that quirk is now fixed).
+ * never masks an env var (`PIWI_PROJECT_NAME` would otherwise be masked by the
+ * `default-project` default).
  *
  * One preserved quirk: `PIWI_VERBOSE` wins over both the default *and* an
- * explicit user option, matching the pre-Phase-4 behavior.
+ * explicit user option.
  */
 function resolveOptions(raw) {
     const env = process.env;
     const mergedRaw = { ...raw };
-    // String options: env fills in when the caller didn't provide one.
-    if (mergedRaw.serverUrl === undefined && env[exports.PIWI_ENV_KEYS.serverUrl])
-        mergedRaw.serverUrl = env[exports.PIWI_ENV_KEYS.serverUrl];
-    if (mergedRaw.projectName === undefined && env[exports.PIWI_ENV_KEYS.projectName])
-        mergedRaw.projectName = env[exports.PIWI_ENV_KEYS.projectName];
-    if (mergedRaw.apiKey === undefined && env[exports.PIWI_ENV_KEYS.apiKey])
-        mergedRaw.apiKey = env[exports.PIWI_ENV_KEYS.apiKey];
-    if (mergedRaw.username === undefined && env[exports.PIWI_ENV_KEYS.username])
-        mergedRaw.username = env[exports.PIWI_ENV_KEYS.username];
-    if (mergedRaw.password === undefined && env[exports.PIWI_ENV_KEYS.password])
-        mergedRaw.password = env[exports.PIWI_ENV_KEYS.password];
-    if (mergedRaw.environment === undefined && env[exports.PIWI_ENV_KEYS.environment])
-        mergedRaw.environment = env[exports.PIWI_ENV_KEYS.environment];
-    if (mergedRaw.label === undefined && env[exports.PIWI_ENV_KEYS.label])
-        mergedRaw.label = env[exports.PIWI_ENV_KEYS.label];
-    if (mergedRaw.runLabel === undefined && env[exports.PIWI_ENV_KEYS.runLabel])
-        mergedRaw.runLabel = env[exports.PIWI_ENV_KEYS.runLabel];
-    // Boolean / numeric options: env fills in when the caller didn't provide one.
-    if (mergedRaw.streaming === undefined && env[exports.PIWI_ENV_KEYS.streaming] !== undefined)
-        mergedRaw.streaming = readBool(env[exports.PIWI_ENV_KEYS.streaming]);
-    if (mergedRaw.streamingBatchSize === undefined && env[exports.PIWI_ENV_KEYS.streamingBatchSize])
-        mergedRaw.streamingBatchSize = Number(env[exports.PIWI_ENV_KEYS.streamingBatchSize]);
-    if (mergedRaw.streamingBatchDelay === undefined && env[exports.PIWI_ENV_KEYS.streamingBatchDelay])
-        mergedRaw.streamingBatchDelay = Number(env[exports.PIWI_ENV_KEYS.streamingBatchDelay]);
-    if (mergedRaw.liveFileUploads === undefined && env[exports.PIWI_ENV_KEYS.liveFileUploads] !== undefined)
-        mergedRaw.liveFileUploads = readBool(env[exports.PIWI_ENV_KEYS.liveFileUploads]);
-    if (mergedRaw.uploadTraces === undefined && env[exports.PIWI_ENV_KEYS.uploadTraces] !== undefined)
-        mergedRaw.uploadTraces = readBool(env[exports.PIWI_ENV_KEYS.uploadTraces]);
-    if (mergedRaw.uploadReport === undefined && env[exports.PIWI_ENV_KEYS.uploadReport] !== undefined)
-        mergedRaw.uploadReport = readBool(env[exports.PIWI_ENV_KEYS.uploadReport]);
-    if (mergedRaw.captureLocators === undefined && env[exports.PIWI_ENV_KEYS.captureLocators] !== undefined)
-        mergedRaw.captureLocators = readBool(env[exports.PIWI_ENV_KEYS.captureLocators]);
+    for (const spec of ENV_FALLBACK_SPECS) {
+        if (mergedRaw[spec.option] !== undefined)
+            continue;
+        const value = env[spec.env];
+        if (spec.kind === 'bool') {
+            if (value !== undefined)
+                mergedRaw[spec.option] = readBool(value);
+        }
+        else if (value) {
+            mergedRaw[spec.option] = spec.kind === 'number' ? Number(value) : value;
+        }
+    }
     const opts = { ...DEFAULTS, ...mergedRaw };
     // Preserved quirk: PIWI_VERBOSE wins over both default and user option.
     if (env[exports.PIWI_ENV_KEYS.verbose] !== undefined)

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) {