@piwitests/reporter 0.5.0 → 0.7.0

package/dist/{config-wrapper.js → public/config-wrapper.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapConfig = wrapConfig;
-const config_js_1 = require("./config.js");
+const env_js_1 = require("../internal/config/env.js");
 const PIWI_MODULE = '@piwitests/reporter';
 function isPiwiReporterEntry(entry) {
     if (typeof entry === 'string')
@@ -23,10 +23,10 @@ function injectReporter(reporter, piwiOptions) {
 }
 function resolveSetupModule() {
     try {
-        return require.resolve('./global-setup-module.js');
+        return require.resolve('../global-setup-module.js');
     }
     catch {
-        return require.resolve('./global-setup-module.ts');
+        return require.resolve('../global-setup-module.ts');
     }
 }
 /**
@@ -49,7 +49,7 @@ function resolveSetupModule() {
  */
 function wrapConfig(config, piwiOptions) {
     if (piwiOptions)
-        (0, config_js_1.applyOptionsToEnv)(piwiOptions);
+        (0, env_js_1.applyOptionsToEnv)(piwiOptions);
     const globalSetupModules = [];
     if (config.globalSetup) {
         const orig = Array.isArray(config.globalSetup) ? config.globalSetup : [config.globalSetup];

package/dist/public/global-setup.d.ts

@@ -0,0 +1,13 @@
+import type { PiwiDashboardOptions } from './options.js';
+/**
+ * Create a Playwright `globalSetup` function that registers a test run on the
+ * Piwi Dashboard server at the start of the run.  An optional `userSetup` is
+ * called afterward so existing setup logic is preserved.
+ *
+ * The server-run ID and a one-time token are written to a temp file so the
+ * reporter instance can pick them up during the streaming handshake.
+ *
+ * @param options   Piwi Dashboard options (uses `serverUrl`, `projectName`, …).
+ * @param userSetup An existing global setup to chain after the Piwi registration.
+ */
+export declare function createGlobalSetup(options?: PiwiDashboardOptions, userSetup?: (config: any) => any): (config: any) => Promise<any>;

package/dist/public/global-setup.js

@@ -0,0 +1,146 @@
+"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.createGlobalSetup = createGlobalSetup;
+const path = __importStar(require("node:path"));
+const errors_js_1 = require("../internal/support/errors.js");
+const fs = __importStar(require("node:fs"));
+const env_js_1 = require("../internal/config/env.js");
+const http_client_js_1 = require("../internal/transport/http-client.js");
+const logger_js_1 = require("../internal/support/logger.js");
+const instance_id_js_1 = require("../internal/support/instance-id.js");
+const ci_js_1 = require("../internal/support/ci.js");
+const setup_file_js_1 = require("../internal/support/setup-file.js");
+/**
+ * Create a Playwright `globalSetup` function that registers a test run on the
+ * Piwi Dashboard server at the start of the run.  An optional `userSetup` is
+ * called afterward so existing setup logic is preserved.
+ *
+ * The server-run ID and a one-time token are written to a temp file so the
+ * reporter instance can pick them up during the streaming handshake.
+ *
+ * @param options   Piwi Dashboard options (uses `serverUrl`, `projectName`, …).
+ * @param userSetup An existing global setup to chain after the Piwi registration.
+ */
+function createGlobalSetup(options, userSetup) {
+    return async function globalSetupFn(config) {
+        // This module compiles to `dist/public/global-setup.js`; the package entry
+        // point is `dist/index.js`, one level up.
+        const piwiReporterPath = path.resolve(__dirname, '../index.js');
+        // Extract options from the Piwi reporter entry in the Playwright config so
+        // that serverUrl / projectName etc. set inline in the reporters array are
+        // visible here without requiring PIWI_* env vars or a separate wrapConfig call.
+        let inlineReporterOptions = {};
+        if (Array.isArray(config?.reporter)) {
+            for (const r of config.reporter) {
+                if (!Array.isArray(r) || typeof r[0] !== 'string')
+                    continue;
+                const isPiwi = r[0].toLowerCase().includes('piwi') ||
+                    (() => {
+                        try {
+                            return path.resolve(require.resolve(r[0])) === piwiReporterPath;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })();
+                if (isPiwi && r[1] && typeof r[1] === 'object') {
+                    inlineReporterOptions = r[1];
+                    break;
+                }
+            }
+        }
+        const opts = (0, env_js_1.resolveOptions)({ ...inlineReporterOptions, ...options });
+        const logger = new logger_js_1.Logger(opts.verbose ?? false);
+        if (opts.enabled === false || !opts.serverUrl) {
+            logger.info('Not enabled — set PIWI_DASHBOARD_URL or serverUrl to enable.');
+            if (userSetup)
+                return userSetup(config);
+            return;
+        }
+        const hasPiwi = Object.keys(inlineReporterOptions).length > 0 ||
+            (Array.isArray(config?.reporter) &&
+                config.reporter.some((r) => {
+                    if (!Array.isArray(r) || typeof r[0] !== 'string')
+                        return false;
+                    if (r[0].toLowerCase().includes('piwi'))
+                        return true;
+                    try {
+                        return path.resolve(require.resolve(r[0])) === piwiReporterPath;
+                    }
+                    catch {
+                        return false;
+                    }
+                }));
+        if (!hasPiwi) {
+            logger.debug('Not reporting — Piwi is not in the Playwright reporters list.');
+            if (userSetup)
+                return userSetup(config);
+            return;
+        }
+        const httpClient = new http_client_js_1.HttpClient(opts.serverUrl, logger);
+        try {
+            const auth = await httpClient.resolveAuth(opts);
+            const runLabel = opts.runLabel || (0, ci_js_1.detectCiRunLabel)();
+            // Detect shard info from Playwright config (--shard=1/3)
+            const pwShard = config.shard;
+            const shardIndex = pwShard?.current;
+            const shardTotal = pwShard?.total;
+            const response = await httpClient.postJSON('/api/test-runs/setup', {
+                projectName: opts.projectName,
+                projectDescription: opts.projectDescription,
+                environment: opts.environment || null,
+                label: opts.label || null,
+                startTime: new Date().toISOString(),
+                instanceId: (0, instance_id_js_1.computeInstanceId)(opts.projectName, runLabel),
+                shardIndex,
+                shardTotal,
+            }, auth);
+            if (response?.runId && response?.setupToken) {
+                fs.writeFileSync((0, setup_file_js_1.getSetupFilePath)(opts.projectName), JSON.stringify({
+                    runId: response.runId,
+                    setupToken: response.setupToken,
+                    projectName: opts.projectName,
+                }));
+                logger.debug(`Global setup: initialising run #${response.runId}`);
+            }
+        }
+        catch (error) {
+            logger.warn(`Could not register global setup: ${(0, errors_js_1.errorMessage)(error)}`);
+        }
+        if (userSetup)
+            return userSetup(config);
+    };
+}

package/dist/{config.d.ts → public/options.d.ts}

@@ -1,6 +1,12 @@
 import type { PlaywrightTestConfig } from '@playwright/test';
 export type { PlaywrightTestConfig } from '@playwright/test';
-/** Playwright shard info — mirrors `config.shard` shape */
+/**
+ * Playwright shard info — mirrors `config.shard` shape.
+ *
+ * Internal shape: it is NOT re-exported from the package entry point, but it
+ * lives here next to the configuration types because it describes the same
+ * `config.shard` surface the options come from. May move to `types/wire.ts`.
+ */
 export interface ShardInfo {
     current: number;
     total: number;
@@ -70,47 +76,3 @@ export interface PiwiDashboardOptions extends PlaywrightTestConfig {
     /** Enable verbose logging for debugging. Defaults to `false`. */
     verbose?: boolean;
 }
-/**
- * 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 (the pre-Phase-4 `PIWI_PROJECT_NAME` was masked by the
- * `default-project` default — that quirk is now fixed).
- *
- * One preserved quirk: `PIWI_VERBOSE` wins over both the default *and* an
- * explicit user option, matching the pre-Phase-4 behavior.
- */
-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/public/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{reporter.d.ts → public/reporter.d.ts}

@@ -1,5 +1,5 @@
 import type { FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
-import { createGlobalSetup } from './helpers.js';
+import { createGlobalSetup } from './global-setup.js';
 import { wrapConfig } from './config-wrapper.js';
 /**
  * Piwi Dashboard Playwright reporter.

package/dist/{reporter.js → public/reporter.js}

@@ -34,45 +34,37 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PiwiDashboardReporter = void 0;
-const path = __importStar(require("path"));
-const config_js_1 = require("./config.js");
-const http_client_js_1 = require("./http-client.js");
-const uploader_js_1 = require("./uploader.js");
-const stream_buffer_js_1 = require("./stream-buffer.js");
-const crash_recovery_js_1 = require("./crash-recovery.js");
-const file_handler_js_1 = require("./file-handler.js");
-const metadata_collector_js_1 = require("./metadata-collector.js");
-const stream_manager_js_1 = require("./stream-manager.js");
-const step_analyzer_js_1 = require("./step-analyzer.js");
-const helpers_js_1 = require("./helpers.js");
+const path = __importStar(require("node:path"));
+const env_js_1 = require("../internal/config/env.js");
+const http_client_js_1 = require("../internal/transport/http-client.js");
+const uploader_js_1 = require("../internal/submit/uploader.js");
+const stream_buffer_js_1 = require("../internal/streaming/stream-buffer.js");
+const crash_recovery_js_1 = require("../internal/streaming/crash-recovery.js");
+const file_handler_js_1 = require("../internal/files/file-handler.js");
+const attachments_js_1 = require("../internal/capture/attachments.js");
+const metadata_collector_js_1 = require("../internal/collect/metadata-collector.js");
+const stream_manager_js_1 = require("../internal/streaming/stream-manager.js");
+const step_analyzer_js_1 = require("../internal/collect/step-analyzer.js");
+const instance_id_js_1 = require("../internal/support/instance-id.js");
+const source_snippet_js_1 = require("../internal/support/source-snippet.js");
+const ci_js_1 = require("../internal/support/ci.js");
+const worker_index_js_1 = require("../internal/support/worker-index.js");
+const cli_filters_js_1 = require("../internal/support/cli-filters.js");
+const global_setup_js_1 = require("./global-setup.js");
 const config_wrapper_js_1 = require("./config-wrapper.js");
-const serializer_js_1 = require("./serializer.js");
-const skip_classify_js_1 = require("./skip-classify.js");
-const run_submitter_js_1 = require("./run-submitter.js");
-const logger_js_1 = require("./logger.js");
+const serializer_js_1 = require("../internal/submit/serializer.js");
+const skip_classify_js_1 = require("../internal/collect/skip-classify.js");
+const error_text_js_1 = require("../internal/collect/error-text.js");
+const run_submitter_js_1 = require("../internal/submit/run-submitter.js");
+const logger_js_1 = require("../internal/support/logger.js");
 /**
- * Build the stored error text for a test result.
- *
- * Playwright's `error.message` carries the failure message and call log but no
- * stack frames — those live on `error.stack`/`error.location`. The server's
- * locator-healing lookup needs the failing call site to find the pre-captured
- * snapshot for that locator, so when the message has no `at …` frame we append
- * a synthetic one from `error.location`, relativized to the cwd so it matches
- * the format the fixture records at capture time. The frame is appended after
- * the message, where `extractMessageHead` already trims it off before
- * fingerprinting — so failure clustering is unaffected.
+ * Relative `file:line:column` location string for a test, normalized to POSIX
+ * path separators so Playwright's CLI file filter (and the dashboard's copyable
+ * retry command) match on every platform — `path.relative` yields backslashes on Windows.
  */
-function buildErrorText(result) {
-    const err = result.error;
-    if (!err)
-        return null;
-    let text = err.message ?? '';
-    const loc = err.location;
-    if (loc?.file && !/\n\s+at\s/.test(text)) {
-        const rel = path.relative(process.cwd(), loc.file).split(path.sep).join('/');
-        text += `\n    at ${rel}:${loc.line}:${loc.column}`;
-    }
-    return text;
+function testLocation(test) {
+    const relativeFilePath = path.relative(process.cwd(), test.location.file).split(path.sep).join('/');
+    return `${relativeFilePath}:${test.location.line}:${test.location.column}`;
 }
 /**
  * Piwi Dashboard Playwright reporter.
@@ -105,10 +97,10 @@ class PiwiDashboardReporter {
         this.streamManager = null;
         /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
         this.setupSteps = [];
-        this.options = (0, config_js_1.resolveOptions)(rawOptions);
+        this.options = (0, env_js_1.resolveOptions)(rawOptions);
         this.enabled = this.options.enabled !== false && !!this.options.serverUrl;
-        this.runLabel = this.options.runLabel || (0, helpers_js_1.detectCiRunLabel)();
-        this.instanceId = (0, helpers_js_1.computeInstanceId)(this.options.projectName, this.runLabel);
+        this.runLabel = this.options.runLabel || (0, ci_js_1.detectCiRunLabel)();
+        this.instanceId = (0, instance_id_js_1.computeInstanceId)(this.options.projectName, this.runLabel);
         const logger = new logger_js_1.Logger(this.options.verbose ?? false);
         this.logger = logger;
         this.httpClient = new http_client_js_1.HttpClient(this.options.serverUrl ?? 'http://localhost:3000', logger);
@@ -140,7 +132,7 @@ class PiwiDashboardReporter {
         const grep = grepRe && grepRe.source !== '.*' ? grepRe.source : undefined;
         const grepInvert = grepInvertRe?.source;
         // File/path filters come from the CLI invocation, not config.grep.
-        const fileFilters = (0, helpers_js_1.detectCliFileFilters)();
+        const fileFilters = (0, cli_filters_js_1.detectCliFileFilters)();
         if (grep || grepInvert || fileFilters.length > 0) {
             this.isFullRun = false;
             this.filterDetails = {
@@ -166,13 +158,12 @@ class PiwiDashboardReporter {
     }
     /** Playwright reporter hook: called when an individual test begins */
     onTestBegin(test, result) {
-        const relativeFilePath = path.relative(process.cwd(), test.location.file);
         const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
         const beginEvent = {
             type: 'begin',
             title: test.title,
-            location: `${relativeFilePath}:${test.location.line}:${test.location.column}`,
-            workerIndex: (0, helpers_js_1.workerIndexOf)(result),
+            location: testLocation(test),
+            workerIndex: (0, worker_index_js_1.workerIndexOf)(result),
             shardIndex: this.shardInfo?.current ?? null,
             browser: this.metadataCollector.getBrowserConfig(test) || undefined,
             suitePath,
@@ -195,7 +186,7 @@ class PiwiDashboardReporter {
             location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : 'unknown',
             stepCategory: cat,
             parentTitle: test?.title || null,
-            workerIndex: (0, helpers_js_1.workerIndexOf)(_result),
+            workerIndex: (0, worker_index_js_1.workerIndexOf)(_result),
             startedAt: step.startTime instanceof Date ? step.startTime.getTime() : null,
         };
         this.streamManager?.queueBeginEvent(event);
@@ -209,7 +200,7 @@ class PiwiDashboardReporter {
             return;
         if (cat !== 'hook' && cat !== 'fixture')
             return;
-        const workerIndex = (0, helpers_js_1.workerIndexOf)(_result);
+        const workerIndex = (0, worker_index_js_1.workerIndexOf)(_result);
         const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : null;
         const event = {
             type: 'step-end',
@@ -239,7 +230,6 @@ class PiwiDashboardReporter {
     /** Playwright reporter hook: called when an individual test finishes */
     onTestEnd(test, result) {
         this.totalTests++;
-        const relativeFilePath = path.relative(process.cwd(), test.location.file);
         this.reportedTestIds.add(test.id);
         const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
         const annotations = (0, skip_classify_js_1.mergeAnnotations)(test, result);
@@ -247,12 +237,12 @@ class PiwiDashboardReporter {
         const testCase = {
             type: 'complete',
             title: test.title,
-            location: `${relativeFilePath}:${test.location.line}:${test.location.column}`,
+            location: testLocation(test),
             status,
             duration: result.duration,
-            error: buildErrorText(result),
+            error: (0, error_text_js_1.buildErrorText)(result),
             retries: result.retry,
-            workerIndex: (0, helpers_js_1.workerIndexOf)(result),
+            workerIndex: (0, worker_index_js_1.workerIndexOf)(result),
             shardIndex: this.shardInfo?.current ?? null,
             startedAt: result.startTime ? result.startTime.getTime() : null,
             attachments: result.attachments || [],
@@ -262,7 +252,8 @@ class PiwiDashboardReporter {
             testAnnotations: annotations.length ? annotations : null,
         };
         if (result.status === 'failed' || result.status === 'timedOut') {
-            const snippet = (0, helpers_js_1.readSourceSnippet)(test.location.file, test.location.line, 30);
+            const failingLine = (0, source_snippet_js_1.extractFailingLine)(testCase.error, test.location.file, test.location.line);
+            const snippet = (0, source_snippet_js_1.readSourceSnippet)(test.location.file, test.location.line, 30, failingLine);
             if (snippet)
                 testCase.testSource = snippet;
         }
@@ -280,7 +271,7 @@ class PiwiDashboardReporter {
             // (captured in the fixture at action call time). No index correlation
             // with pw:api steps — that was unreliable across workers/concurrent calls.
             const locatorAttachment = this.options.captureLocators !== false
-                ? result.attachments.find((a) => a.name === 'piwi-dashboard-locators')
+                ? result.attachments.find((a) => a.name === attachments_js_1.ATTACHMENT_NAMES.locators)
                 : undefined;
             if (locatorAttachment?.body) {
                 try {
@@ -326,12 +317,11 @@ class PiwiDashboardReporter {
         for (const test of this.plannedTests) {
             if (this.reportedTestIds.has(test.id))
                 continue;
-            const relativeFilePath = path.relative(process.cwd(), test.location.file);
             const { suitePath, suiteConfig } = this.metadataCollector.getSuiteInfo(test);
             const testCase = {
                 type: 'complete',
                 title: test.title,
-                location: `${relativeFilePath}:${test.location.line}:${test.location.column}`,
+                location: testLocation(test),
                 status: 'didnotrun',
                 duration: 0,
                 error: null,
@@ -380,4 +370,4 @@ class PiwiDashboardReporter {
 }
 exports.PiwiDashboardReporter = PiwiDashboardReporter;
 PiwiDashboardReporter.wrapConfig = config_wrapper_js_1.wrapConfig;
-PiwiDashboardReporter.createGlobalSetup = helpers_js_1.createGlobalSetup;
+PiwiDashboardReporter.createGlobalSetup = global_setup_js_1.createGlobalSetup;

package/dist/types/collected.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Internal collection model — the shapes the reporter accumulates *in process*
+ * while a run executes.
+ *
+ * These are NOT sent to the server verbatim: the wire projection happens in
+ * `serializer.ts` (`toWireTestCase` / `serializeRun`) at the JSON boundary. For
+ * the external server contract, see `./wire.ts`.
+ */
+import type { BrowserConfig, SuiteConfigEntry, TestAnnotation, TestStepEvent } from './wire.js';
+import type { LocatorSnapshot } from '../internal/capture/locator-healing.js';
+/**
+ * A raw Playwright attachment as exposed on `TestResult.attachments`.
+ * Carried verbatim on `CollectedTestCase.attachments` so `FileHandler` can
+ * resolve trace/attachment paths; never sent to the server.
+ */
+export interface RawAttachment {
+    name: string;
+    path?: string;
+    contentType?: string;
+    body?: Buffer;
+    originalName?: string;
+}
+/** Performance metrics collected from `result.steps` by `step-analyzer`. */
+export interface CollectedPerformanceMetrics {
+    steps: Array<{
+        title: string;
+        duration: number;
+        category: string;
+        error?: {
+            message: string;
+        };
+        failed?: boolean;
+    }>;
+    totalStepDuration: number;
+    slowestStep: {
+        title: string;
+        duration: number;
+    } | null;
+    navigationCount: number;
+    navigationTotalDuration: number;
+    waitTotalDuration: number;
+    waitCount: number;
+}
+/**
+ * What `onTestEnd` accumulates per test case. Mixes three concerns that the
+ * reporter must keep together during a run:
+ *  - **wire fields** (`title`, `status`, `duration`, …) that `toWireTestCase`
+ *    projects onto `WireTestCase` before sending,
+ *  - **collection-only state** (`attachments`, `performanceMetrics`,
+ *    `stepEvents`) consumed by `FileHandler` and the run-level summary,
+ *  - the `type` discriminant so the same collected object can be queued as a
+ *    stream event.
+ *
+ * Upload bookkeeping (`_filesUploaded`) is deliberately NOT on this object —
+ * `StreamManager` tracks it in a side `Set` so the data model stays clean.
+ */
+export interface CollectedTestCase {
+    /** Stream-event discriminant: `'begin'` or `'complete'`. Omitted for batch-only runs. */
+    type?: 'begin' | 'complete';
+    title: string;
+    location: string;
+    status?: string;
+    duration?: number;
+    error?: string | null;
+    retries?: number;
+    workerIndex?: number | null;
+    shardIndex?: number | null;
+    startedAt?: number | null;
+    /** Raw Playwright attachments — never sent on the wire. */
+    attachments?: RawAttachment[];
+    browser?: BrowserConfig | null;
+    suitePath?: string[] | null;
+    suiteConfig?: SuiteConfigEntry[] | null;
+    testAnnotations?: TestAnnotation[] | null;
+    /** Source snippet around the failing line (failed/timedOut only). */
+    testSource?: string;
+    /** Step metrics from `collectStepMetrics`. Consumed by the run summary + `toWireTestCase`. */
+    performanceMetrics?: CollectedPerformanceMetrics;
+    stepEvents?: TestStepEvent[];
+    /** Parsed from `piwi-network` attachments by `FileHandler`. */
+    networkRequests?: unknown;
+    /** Parsed from `piwi-web-vitals` attachments. */
+    webVitals?: unknown;
+    /** Parsed from `piwi-console` attachments. */
+    consoleLogs?: unknown;
+    /** Parsed from `piwi-aria-snapshot` attachment. */
+    ariaSnapshot?: string;
+    /** Parsed from `piwi-locators` attachment. */
+    locatorSnapshots?: LocatorSnapshot[];
+}
+/** Hash + size of a single trace file, used for dedup against the server. */
+export interface TraceHashInfo {
+    tracePath: string;
+    hash: string;
+    size: number;
+}

package/dist/types/collected.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Internal collection model — the shapes the reporter accumulates *in process*
+ * while a run executes.
+ *
+ * These are NOT sent to the server verbatim: the wire projection happens in
+ * `serializer.ts` (`toWireTestCase` / `serializeRun`) at the JSON boundary. For
+ * the external server contract, see `./wire.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });