@piwitests/reporter 0.4.2

package/dist/metadata-collector.js

@@ -0,0 +1,243 @@
+"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");
+/**
+ * Collects CI/CD environment metadata, SCM (git) information, and Playwright
+ * config metadata to attach to each test run submission.
+ *
+ * Also owns all reach-through access to Playwright-internal suite fields
+ * (`_parallelMode`, `_annotations`, `project()`) so the surface area that
+ * breaks when Playwright renames those internals is guarded behind one class.
+ */
+class MetadataCollector {
+    constructor(logger = new logger_js_1.Logger()) {
+        this.logger = logger;
+    }
+    /** Collect all available metadata from the environment, config, and suite */
+    collect(config, suite, options) {
+        const metadata = {};
+        if (options.projectDescription)
+            metadata.projectDescription = options.projectDescription;
+        if (options.relatedIssue)
+            metadata.relatedIssue = options.relatedIssue;
+        if (options.ciInfo)
+            metadata.ciInfo = options.ciInfo;
+        if (options.tags && Array.isArray(options.tags))
+            metadata.tags = options.tags;
+        if (options.customData)
+            metadata.customData = options.customData;
+        if (options.collectScmInfo) {
+            const scm = this.collectScmInfo(options);
+            if (scm)
+                metadata.scm = scm;
+        }
+        if (options.collectCiInfo) {
+            const ci = this.collectCiInfo();
+            if (ci)
+                metadata.ci = ci;
+        }
+        const htmlMeta = this.extractPlaywrightConfigMetadata(config);
+        if (htmlMeta && Object.keys(htmlMeta).length > 0)
+            metadata.htmlReport = htmlMeta;
+        if (config.metadata)
+            metadata.playwrightConfig = config.metadata;
+        if (suite?.allTests) {
+            const all = suite.allTests();
+            if (all.length > 0) {
+                const first = all[0];
+                if (first?.parent?.project) {
+                    const proj = first.parent.project();
+                    if (proj?.metadata)
+                        metadata.playwrightProject = proj.metadata;
+                }
+            }
+        }
+        return metadata;
+    }
+    /** Walk the test's parent hierarchy to extract the resolved browser/project configuration */
+    getBrowserConfig(test) {
+        try {
+            let suite = test.parent;
+            let depth = 0;
+            while (suite && depth < 20) {
+                depth++;
+                const project = suite.project?.();
+                if (project) {
+                    const use = project.use ?? {};
+                    const config = { projectName: project.name };
+                    if (use.browserName)
+                        config.browserName = use.browserName;
+                    if (use.channel)
+                        config.channel = use.channel;
+                    if (use.viewport)
+                        config.viewport = { width: use.viewport.width, height: use.viewport.height };
+                    if (use.deviceScaleFactor != null)
+                        config.deviceScaleFactor = use.deviceScaleFactor;
+                    if (use.isMobile != null)
+                        config.isMobile = use.isMobile;
+                    if (use.hasTouch != null)
+                        config.hasTouch = use.hasTouch;
+                    if (use.locale)
+                        config.locale = use.locale;
+                    if (use.timezoneId)
+                        config.timezoneId = use.timezoneId;
+                    if (use.geolocation) {
+                        config.geolocation = {
+                            longitude: use.geolocation.longitude,
+                            latitude: use.geolocation.latitude,
+                            ...(use.geolocation.accuracy != null && { accuracy: use.geolocation.accuracy }),
+                        };
+                    }
+                    if (use.colorScheme)
+                        config.colorScheme = use.colorScheme;
+                    if (use.reducedMotion)
+                        config.reducedMotion = use.reducedMotion;
+                    if (use.forcedColors)
+                        config.forcedColors = use.forcedColors;
+                    if (use.offline)
+                        config.offline = use.offline;
+                    if (use.bypassCSP)
+                        config.bypassCSP = use.bypassCSP;
+                    if (use.javaScriptEnabled === false)
+                        config.javaScriptEnabled = false;
+                    if (use.serviceWorkers)
+                        config.serviceWorkers = use.serviceWorkers;
+                    if (use.userAgent)
+                        config.userAgent = use.userAgent;
+                    return config;
+                }
+                suite = suite.parent;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Walk the test's parent `describe` suites to extract the suite path (titles)
+     * and per-level config (parallel mode + annotations). Reaches into Playwright
+     * suite internals (`_parallelMode`, `_annotations`) — kept here next to
+     * `getBrowserConfig` so all such access is guarded behind one class.
+     */
+    getSuiteInfo(test) {
+        const suitePath = [];
+        const suiteConfig = [];
+        const suites = [];
+        let suite = test.parent;
+        while (suite && suite.type === 'describe') {
+            suites.unshift(suite);
+            suite = suite.parent;
+        }
+        for (const s of suites) {
+            if (!s.title)
+                continue;
+            suitePath.push(s.title);
+            const rawMode = s._parallelMode;
+            const mode = rawMode === 'parallel' ? 'parallel' : rawMode === 'serial' ? 'serial' : 'default';
+            const annotations = s._annotations ?? [];
+            suiteConfig.push({ mode, annotations });
+        }
+        return { suitePath, suiteConfig };
+    }
+    collectScmInfo(_options) {
+        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();
+            try {
+                scm.remoteUrl = (0, 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}`);
+        }
+        return Object.keys(scm).length > 0 ? scm : undefined;
+    }
+    collectCiInfo() {
+        const ci = {};
+        const env = process.env;
+        if (env.JENKINS_URL) {
+            ci.provider = 'Jenkins';
+            ci.buildNumber = env.BUILD_NUMBER;
+            ci.buildUrl = env.BUILD_URL;
+            ci.jobName = env.JOB_NAME;
+        }
+        else if (env.GITHUB_ACTIONS) {
+            ci.provider = 'GitHub Actions';
+            ci.runId = env.GITHUB_RUN_ID;
+            ci.runNumber = env.GITHUB_RUN_NUMBER;
+            ci.workflow = env.GITHUB_WORKFLOW;
+            ci.actor = env.GITHUB_ACTOR;
+            ci.repository = env.GITHUB_REPOSITORY;
+            ci.ref = env.GITHUB_REF;
+            ci.sha = env.GITHUB_SHA;
+            ci.serverUrl = env.GITHUB_SERVER_URL;
+            if (ci.serverUrl && ci.repository && ci.runId) {
+                ci.buildUrl = `${ci.serverUrl}/${ci.repository}/actions/runs/${ci.runId}`;
+            }
+        }
+        else if (env.GITLAB_CI) {
+            ci.provider = 'GitLab CI';
+            ci.pipelineId = env.CI_PIPELINE_ID;
+            ci.pipelineUrl = env.CI_PIPELINE_URL;
+            ci.jobId = env.CI_JOB_ID;
+            ci.jobUrl = env.CI_JOB_URL;
+            ci.jobName = env.CI_JOB_NAME;
+        }
+        else if (env.CIRCLECI) {
+            ci.provider = 'CircleCI';
+            ci.buildNumber = env.CIRCLE_BUILD_NUM;
+            ci.buildUrl = env.CIRCLE_BUILD_URL;
+            ci.jobName = env.CIRCLE_JOB;
+            ci.workflow = env.CIRCLE_WORKFLOW_ID;
+        }
+        else if (env.TRAVIS) {
+            ci.provider = 'Travis CI';
+            ci.buildNumber = env.TRAVIS_BUILD_NUMBER;
+            ci.buildUrl = env.TRAVIS_BUILD_WEB_URL;
+            ci.jobNumber = env.TRAVIS_JOB_NUMBER;
+        }
+        else if (env.TF_BUILD) {
+            ci.provider = 'Azure Pipelines';
+            ci.buildNumber = env.BUILD_BUILDNUMBER;
+            ci.buildId = env.BUILD_BUILDID;
+            if (env.SYSTEM_TEAMFOUNDATIONSERVERURI && env.SYSTEM_TEAMPROJECT && env.BUILD_BUILDID) {
+                ci.buildUrl = `${env.SYSTEM_TEAMFOUNDATIONSERVERURI}${env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${env.BUILD_BUILDID}`;
+            }
+            ci.jobName = env.AGENT_JOBNAME;
+        }
+        else if (env.CI) {
+            ci.provider = 'Unknown CI';
+            ci.detected = true;
+        }
+        return Object.keys(ci).length > 0 ? ci : undefined;
+    }
+    extractPlaywrightConfigMetadata(config) {
+        const meta = {};
+        if (config.projects?.length > 0) {
+            meta.projects = config.projects.map((p) => ({
+                name: p.name,
+                testDir: p.testDir,
+                use: {
+                    browserName: p.use?.browserName || p.name,
+                    viewport: p.use?.viewport,
+                    deviceScaleFactor: p.use?.deviceScaleFactor,
+                },
+            }));
+        }
+        meta.workers = config.workers;
+        meta.timeout = config.globalTimeout;
+        meta.fullyParallel = config.fullyParallel;
+        return meta;
+    }
+}
+exports.MetadataCollector = MetadataCollector;

package/dist/reporter.d.ts

@@ -0,0 +1,65 @@
+import type { FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+import { createGlobalSetup } from './helpers.js';
+/**
+ * Piwi Dashboard Playwright reporter.
+ *
+ * Collects test results, metadata, performance metrics and trace files, then
+ * hands the collected run to a `RunSubmitter` which drives the JSON / multipart
+ * / streaming submit ladder. The reporter itself only owns the Playwright hooks
+ * and the running counters.
+ */
+export declare class PiwiDashboardReporter {
+    private options;
+    private testCases;
+    private startTime;
+    private playwrightVersion;
+    private totalTests;
+    private passedTests;
+    private failedTests;
+    private skippedTests;
+    private timedOutTests;
+    private didNotRunTests;
+    /** Full set of tests Playwright planned to run this shard (captured in `onBegin`). */
+    private plannedTests;
+    /** Ids of tests that actually reported via `onTestEnd`, to find the ones that never ran. */
+    private reportedTestIds;
+    private instanceId;
+    private runLabel;
+    private shardInfo;
+    private metadata;
+    private enabled;
+    private isFullRun;
+    private filterDetails;
+    private httpClient;
+    private uploader;
+    private fileHandler;
+    private metadataCollector;
+    private streamManager;
+    private recovery;
+    private submitter;
+    private readonly logger;
+    static createGlobalSetup: typeof createGlobalSetup;
+    constructor(rawOptions?: Record<string, any>);
+    /** Playwright reporter hook: called once at the start of the test run */
+    onBegin(config: FullConfig, suite: Suite): void;
+    /** Playwright reporter hook: called when an individual test begins */
+    onTestBegin(test: TestCase, result: TestResult): void;
+    /** Track suite-level setup steps (beforeAll/afterAll) not tied to any test */
+    private setupSteps;
+    /** Playwright reporter hook: called when a step (including hook/fixture) begins */
+    onStepBegin(test: TestCase | undefined, _result: TestResult | undefined, step: any): void;
+    /** Playwright reporter hook: called when a step (including hook/fixture) ends */
+    onStepEnd(test: TestCase | undefined, _result: TestResult | undefined, step: any): void;
+    /** Playwright reporter hook: called when an individual test finishes */
+    onTestEnd(test: TestCase, result: TestResult): void;
+    /**
+     * Synthesize `didnotrun` cases for tests Playwright planned but never reported
+     * (no `onTestEnd`) — typically because `maxFailures` cut the run short. These
+     * carry no result, so they're emitted with zero duration and no error. In
+     * streaming mode they're queued as complete events so the pre-finish drain
+     * sends them alongside the rest.
+     */
+    private materializeUnrunTests;
+    /** Playwright reporter hook: called when the full test run finishes */
+    onEnd(result: FullResult): Promise<void>;
+}

package/dist/reporter.js

@@ -0,0 +1,341 @@
+"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.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 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");
+/**
+ * Piwi Dashboard Playwright reporter.
+ *
+ * Collects test results, metadata, performance metrics and trace files, then
+ * hands the collected run to a `RunSubmitter` which drives the JSON / multipart
+ * / streaming submit ladder. The reporter itself only owns the Playwright hooks
+ * and the running counters.
+ */
+class PiwiDashboardReporter {
+    constructor(rawOptions = {}) {
+        this.testCases = [];
+        this.startTime = null;
+        this.playwrightVersion = null;
+        this.totalTests = 0;
+        this.passedTests = 0;
+        this.failedTests = 0;
+        this.skippedTests = 0;
+        this.timedOutTests = 0;
+        this.didNotRunTests = 0;
+        /** Full set of tests Playwright planned to run this shard (captured in `onBegin`). */
+        this.plannedTests = [];
+        /** Ids of tests that actually reported via `onTestEnd`, to find the ones that never ran. */
+        this.reportedTestIds = new Set();
+        this.runLabel = null;
+        this.shardInfo = null;
+        this.metadata = {};
+        this.isFullRun = true;
+        this.filterDetails = null;
+        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.enabled = !!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);
+        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);
+        this.fileHandler = new file_handler_js_1.FileHandler(logger);
+        this.uploader = new uploader_js_1.Uploader(this.httpClient, this.fileHandler, logger);
+        this.recovery = new crash_recovery_js_1.CrashRecovery(this.options.projectName, logger);
+        this.metadataCollector = new metadata_collector_js_1.MetadataCollector(logger);
+        const streamBuffer = new stream_buffer_js_1.StreamBuffer(this.options.projectName);
+        streamBuffer.clearStale();
+        if (this.options.streaming) {
+            this.streamManager = new stream_manager_js_1.StreamManager(this.httpClient, streamBuffer, this.recovery, this.uploader, this.fileHandler, this.options, logger);
+        }
+        this.submitter = new run_submitter_js_1.RunSubmitter(this.httpClient, this.uploader, this.recovery, this.streamManager, logger);
+    }
+    /** Playwright reporter hook: called once at the start of the test run */
+    onBegin(config, suite) {
+        if (!this.enabled) {
+            this.logger.info('Not enabled — set PIWI_DASHBOARD_URL or serverUrl to enable.');
+            return;
+        }
+        this.startTime = new Date().toISOString();
+        this.playwrightVersion = config.version;
+        this.logger.info(`Starting test run for project: ${this.options.projectName} (Playwright v${this.playwrightVersion})`);
+        // Detect partial-run filters so the dashboard can distinguish full-suite runs from ad-hoc focused runs.
+        const rawConfig = config;
+        const grepRe = rawConfig.grep instanceof RegExp ? rawConfig.grep : undefined;
+        const grepInvertRe = rawConfig.grepInvert instanceof RegExp ? rawConfig.grepInvert : undefined;
+        // Playwright's default grep is /.*/ (matches everything) — only a non-default pattern is a real filter.
+        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)();
+        if (grep || grepInvert || fileFilters.length > 0) {
+            this.isFullRun = false;
+            this.filterDetails = {
+                ...(grep ? { grep } : {}),
+                ...(grepInvert ? { grepInvert } : {}),
+                ...(fileFilters.length > 0 ? { files: fileFilters } : {}),
+            };
+            this.logger.info('Partial run detected (filter active)');
+        }
+        this.metadata = this.metadataCollector.collect(config, suite, this.options);
+        // Snapshot the planned test list so `onEnd` can materialize tests that
+        // never ran (e.g. cut short by `maxFailures`) as `didnotrun` cases. The
+        // suite is already filtered/sharded, so this matches what this shard
+        // attempts.
+        this.plannedTests = suite.allTests();
+        // Detect Playwright shard config (--shard=1/3)
+        const pwShard = config.shard;
+        if (pwShard?.total && pwShard.total > 1) {
+            this.shardInfo = { current: pwShard.current, total: pwShard.total };
+            this.logger.info(`Shard ${this.shardInfo.current}/${this.shardInfo.total} detected`);
+        }
+        this.streamManager?.start(this.startTime, this.metadata, this.instanceId, this.playwrightVersion, this.shardInfo, this.isFullRun, this.filterDetails);
+    }
+    /** 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),
+            shardIndex: this.shardInfo?.current ?? null,
+            browser: this.metadataCollector.getBrowserConfig(test) || undefined,
+            suitePath,
+            suiteConfig,
+        };
+        if (this.streamManager) {
+            this.streamManager.queueBeginEvent((0, serializer_js_1.toWireTestCase)(beginEvent));
+        }
+    }
+    /** Playwright reporter hook: called when a step (including hook/fixture) begins */
+    onStepBegin(test, _result, step) {
+        if (!this.enabled || !this.streamManager?.enabled)
+            return;
+        const cat = step.category;
+        if (cat !== 'hook' && cat !== 'fixture')
+            return;
+        const event = {
+            type: 'step-begin',
+            title: step.title,
+            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),
+            startedAt: step.startTime instanceof Date ? step.startTime.getTime() : null,
+        };
+        this.streamManager?.queueBeginEvent(event);
+    }
+    /** Playwright reporter hook: called when a step (including hook/fixture) ends */
+    onStepEnd(test, _result, step) {
+        if (!this.enabled || !this.streamManager?.enabled)
+            return;
+        const cat = step.category;
+        if (cat !== 'hook' && cat !== 'fixture')
+            return;
+        const workerIndex = (0, helpers_js_1.workerIndexOf)(_result);
+        const startedAt = step.startTime instanceof Date ? step.startTime.getTime() : null;
+        const event = {
+            type: 'step-end',
+            title: step.title,
+            location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : 'unknown',
+            status: step.error ? 'failed' : 'passed',
+            duration: step.duration || 0,
+            stepCategory: cat,
+            parentTitle: test?.title || null,
+            workerIndex,
+            startedAt,
+        };
+        this.streamManager?.queueEvent(event);
+        // Track suite-level hooks (beforeAll/afterAll) for the timeline
+        if (!test && startedAt) {
+            this.setupSteps.push({
+                title: step.title,
+                category: cat,
+                startedAt,
+                duration: step.duration || 0,
+                status: step.error ? 'failed' : 'passed',
+                location: step.location ? `${step.location.file}:${step.location.line}:${step.location.column}` : null,
+                workerIndex,
+            });
+        }
+    }
+    /** 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);
+        const status = (0, skip_classify_js_1.classifyStatus)(result.status, annotations);
+        const testCase = {
+            type: 'complete',
+            title: test.title,
+            location: `${relativeFilePath}:${test.location.line}:${test.location.column}`,
+            status,
+            duration: result.duration,
+            error: result.error ? result.error.message : null,
+            retries: result.retry,
+            workerIndex: (0, helpers_js_1.workerIndexOf)(result),
+            shardIndex: this.shardInfo?.current ?? null,
+            startedAt: result.startTime ? result.startTime.getTime() : null,
+            attachments: result.attachments || [],
+            browser: this.metadataCollector.getBrowserConfig(test) || undefined,
+            suitePath,
+            suiteConfig,
+            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);
+            if (snippet)
+                testCase.testSource = snippet;
+        }
+        if (this.options.collectPerformanceMetrics && result.steps?.length > 0) {
+            testCase.performanceMetrics = (0, step_analyzer_js_1.collectStepMetrics)(result.steps);
+            const stepEvents = (0, step_analyzer_js_1.extractTestStepEvents)(result.steps, result.startTime);
+            const waitEvents = (0, step_analyzer_js_1.extractWaitEvents)(result.steps);
+            const allEvents = [...stepEvents, ...waitEvents];
+            if (allEvents.length > 0)
+                testCase.stepEvents = allEvents;
+        }
+        if (this.options.collectPerformanceMetrics && result.attachments) {
+            this.fileHandler.parsePerformanceAttachments(testCase, result.attachments);
+        }
+        switch (status) {
+            case 'passed':
+                this.passedTests++;
+                break;
+            case 'failed':
+                this.failedTests++;
+                break;
+            case 'skipped':
+                this.skippedTests++;
+                break;
+            case 'didnotrun':
+                this.didNotRunTests++;
+                break;
+            case 'timedOut':
+                this.timedOutTests++;
+                break;
+        }
+        this.testCases.push(testCase);
+        if (this.streamManager) {
+            this.streamManager.queueEvent((0, serializer_js_1.toWireTestCase)(testCase));
+            if (this.options.liveFileUploads)
+                this.streamManager.scheduleLiveUpload(testCase);
+        }
+    }
+    /**
+     * Synthesize `didnotrun` cases for tests Playwright planned but never reported
+     * (no `onTestEnd`) — typically because `maxFailures` cut the run short. These
+     * carry no result, so they're emitted with zero duration and no error. In
+     * streaming mode they're queued as complete events so the pre-finish drain
+     * sends them alongside the rest.
+     */
+    materializeUnrunTests() {
+        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}`,
+                status: 'didnotrun',
+                duration: 0,
+                error: null,
+                retries: 0,
+                workerIndex: null,
+                shardIndex: this.shardInfo?.current ?? null,
+                startedAt: null,
+                attachments: [],
+                browser: this.metadataCollector.getBrowserConfig(test) || undefined,
+                suitePath,
+                suiteConfig,
+                testAnnotations: test.annotations?.length ? test.annotations : null,
+            };
+            this.testCases.push(testCase);
+            this.totalTests++;
+            this.didNotRunTests++;
+            if (this.streamManager) {
+                this.streamManager.queueEvent((0, serializer_js_1.toWireTestCase)(testCase));
+            }
+        }
+    }
+    /** Playwright reporter hook: called when the full test run finishes */
+    async onEnd(result) {
+        if (!this.enabled)
+            return;
+        this.materializeUnrunTests();
+        await this.submitter.submit({
+            options: this.options,
+            testCases: this.testCases,
+            startTime: this.startTime,
+            playwrightVersion: this.playwrightVersion,
+            totalTests: this.totalTests,
+            passedTests: this.passedTests,
+            failedTests: this.failedTests,
+            skippedTests: this.skippedTests,
+            timedOutTests: this.timedOutTests,
+            didNotRunTests: this.didNotRunTests,
+            metadata: this.metadata,
+            instanceId: this.instanceId,
+            shardInfo: this.shardInfo,
+            setupSteps: this.setupSteps,
+            isFullRun: this.isFullRun,
+            filterDetails: this.filterDetails,
+        }, result);
+    }
+}
+exports.PiwiDashboardReporter = PiwiDashboardReporter;
+PiwiDashboardReporter.createGlobalSetup = helpers_js_1.createGlobalSetup;