@arghajit/dummy 0.1.0 → 0.1.2-beta-1

package/dist/reporter/playwright-pulse-reporter.js

@@ -1,5 +1,4 @@
 "use strict";
-// input_file_0.ts
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -38,14 +37,25 @@ exports.PlaywrightPulseReporter = void 0;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
-const attachment_utils_1 = require("./attachment-utils"); // Use relative path
-const convertStatus = (status, testCase) => {
+const ua_parser_js_1 = require("ua-parser-js");
+const os = __importStar(require("os"));
+const convertStatus = (status, testCase, retryCount = 0) => {
+    // If a test passes on a retry, it's considered flaky regardless of expected status.
+    // This is the most critical check for flaky tests.
+    if (status === "passed" && retryCount > 0) {
+        return "flaky";
+    }
+    // Handle expected statuses for the final result.
     if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "failed") {
+        // If expected to fail but passed, it's flaky.
+        if (status === "passed")
+            return "flaky";
         return "failed";
     }
     if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "skipped") {
         return "skipped";
     }
+    // Default Playwright status mapping
     switch (status) {
         case "passed":
             return "passed";
@@ -60,17 +70,21 @@ const convertStatus = (status, testCase) => {
 };
 const TEMP_SHARD_FILE_PREFIX = ".pulse-shard-results-";
 const ATTACHMENTS_SUBDIR = "attachments";
+const INDIVIDUAL_REPORTS_SUBDIR = "pulse-results";
 class PlaywrightPulseReporter {
     constructor(options = {}) {
-        var _a, _b;
+        var _a, _b, _c;
+        // This will now store all individual run attempts for all tests.
         this.results = [];
         this.baseOutputFile = "playwright-pulse-report.json";
         this.isSharded = false;
         this.shardIndex = undefined;
+        this.currentRunId = ""; // Added to store the overall run ID
         this.options = options;
         this.baseOutputFile = (_a = options.outputFile) !== null && _a !== void 0 ? _a : this.baseOutputFile;
         this.outputDir = (_b = options.outputDir) !== null && _b !== void 0 ? _b : "pulse-report";
         this.attachmentsDir = path.join(this.outputDir, ATTACHMENTS_SUBDIR);
+        this.resetOnEachRun = (_c = options.resetOnEachRun) !== null && _c !== void 0 ? _c : true;
     }
     printsToStdio() {
         return this.shardIndex === undefined || this.shardIndex === 0;
@@ -80,6 +94,8 @@ class PlaywrightPulseReporter {
         this.config = config;
         this.suite = suite;
         this.runStartTime = Date.now();
+        // Generate the overall runId once at the beginning
+        this.currentRunId = `run-${this.runStartTime}-${(0, crypto_1.randomUUID)()}`;
         const configDir = this.config.rootDir;
         const configFileDir = this.config.configFile
             ? path.dirname(this.config.configFile)
@@ -94,7 +110,7 @@ class PlaywrightPulseReporter {
             : undefined;
         this._ensureDirExists(this.outputDir)
             .then(() => {
-            if (this.shardIndex === undefined || this.shardIndex === 0) {
+            if (this.printsToStdio()) {
                 console.log(`PlaywrightPulseReporter: Starting test run with ${suite.allTests().length} tests${this.isSharded ? ` across ${totalShards} shards` : ""}. Pulse outputting to ${this.outputDir}`);
                 if (this.shardIndex === undefined ||
                     (this.isSharded && this.shardIndex === 0)) {
@@ -105,9 +121,60 @@ class PlaywrightPulseReporter {
             .catch((err) => console.error("Pulse Reporter: Error during initialization:", err));
     }
     onTestBegin(test) {
-        // console.log(`Starting test: ${test.title}`);
+        // console.log(`Starting test: ${test.title}`); // Removed for brevity in final output
+    }
+    getBrowserDetails(test) {
+        var _a, _b, _c, _d;
+        const project = (_a = test.parent) === null || _a === void 0 ? void 0 : _a.project();
+        const projectConfig = project === null || project === void 0 ? void 0 : project.use;
+        const userAgent = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.userAgent;
+        const configuredBrowserType = (_b = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.browserName) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        const parser = new ua_parser_js_1.UAParser(userAgent);
+        const result = parser.getResult();
+        let browserName = result.browser.name;
+        const browserVersion = result.browser.version
+            ? ` v${result.browser.version.split(".")[0]}`
+            : "";
+        const osName = result.os.name ? ` on ${result.os.name}` : "";
+        const osVersion = result.os.version
+            ? ` ${result.os.version.split(".")[0]}`
+            : "";
+        const deviceType = result.device.type;
+        let finalString;
+        if (browserName === undefined) {
+            browserName = configuredBrowserType;
+            finalString = `${browserName}`;
+        }
+        else {
+            if (deviceType === "mobile" || deviceType === "tablet") {
+                if ((_c = result.os.name) === null || _c === void 0 ? void 0 : _c.toLowerCase().includes("android")) {
+                    if (browserName.toLowerCase().includes("chrome"))
+                        browserName = "Chrome Mobile";
+                    else if (browserName.toLowerCase().includes("firefox"))
+                        browserName = "Firefox Mobile";
+                    else if (result.engine.name === "Blink" && !result.browser.name)
+                        browserName = "Android WebView";
+                    else if (browserName &&
+                        !browserName.toLowerCase().includes("mobile")) {
+                        // Keep it as is
+                    }
+                    else {
+                        browserName = "Android Browser";
+                    }
+                }
+                else if ((_d = result.os.name) === null || _d === void 0 ? void 0 : _d.toLowerCase().includes("ios")) {
+                    browserName = "Mobile Safari";
+                }
+            }
+            else if (browserName === "Electron") {
+                browserName = "Electron App";
+            }
+            finalString = `${browserName}${browserVersion}${osName}${osVersion}`;
+        }
+        return finalString.trim();
     }
-    async processStep(step, testId, browserName, testCase) {
+    async processStep(step, testId, browserDetails, testCase, retryCount = 0 // Pass retryCount to convertStatus for steps
+    ) {
         var _a, _b, _c, _d;
         let stepStatus = "passed";
         let errorMessage = ((_a = step.error) === null || _a === void 0 ? void 0 : _a.message) || undefined;
@@ -115,7 +182,8 @@ class PlaywrightPulseReporter {
             stepStatus = "skipped";
         }
         else {
-            stepStatus = convertStatus(step.error ? "failed" : "passed", testCase);
+            // Use the extended convertStatus
+            stepStatus = convertStatus(step.error ? "failed" : "passed", testCase, retryCount);
         }
         const duration = step.duration;
         const startTime = new Date(step.startTime);
@@ -124,15 +192,14 @@ class PlaywrightPulseReporter {
         if (step.location) {
             codeLocation = `${path.relative(this.config.rootDir, step.location.file)}:${step.location.line}:${step.location.column}`;
         }
-        let stepTitle = step.title;
         return {
             id: `${testId}_step_${startTime.toISOString()}-${duration}-${(0, crypto_1.randomUUID)()}`,
-            title: stepTitle,
+            title: step.title,
             status: stepStatus,
             duration: duration,
             startTime: startTime,
             endTime: endTime,
-            browser: browserName,
+            browser: browserDetails,
             errorMessage: errorMessage,
             stackTrace: ((_d = step.error) === null || _d === void 0 ? void 0 : _d.stack) || undefined,
             codeLocation: codeLocation || undefined,
@@ -146,21 +213,18 @@ class PlaywrightPulseReporter {
         };
     }
     async onTestEnd(test, result) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const project = (_a = test.parent) === null || _a === void 0 ? void 0 : _a.project();
-        const browserName = ((_b = project === null || project === void 0 ? void 0 : project.use) === null || _b === void 0 ? void 0 : _b.defaultBrowserType) || (project === null || project === void 0 ? void 0 : project.name) || "unknown";
-        const testStatus = convertStatus(result.status, test);
+        const browserDetails = this.getBrowserDetails(test);
+        // Use the extended convertStatus, passing result.retry
+        const testStatus = convertStatus(result.status, test, result.retry);
         const startTime = new Date(result.startTime);
         const endTime = new Date(startTime.getTime() + result.duration);
-        const testIdForFiles = test.id ||
-            `${test
-                .titlePath()
-                .join("_")
-                .replace(/[^a-zA-Z0-9]/g, "_")}_${startTime.getTime()}`;
         const processAllSteps = async (steps) => {
             let processed = [];
             for (const step of steps) {
-                const processedStep = await this.processStep(step, testIdForFiles, browserName, test);
+                const processedStep = await this.processStep(step, test.id, browserDetails, test, result.retry // Pass retryCount to processStep
+                );
                 processed.push(processedStep);
                 if (step.steps && step.steps.length > 0) {
                     processedStep.steps = await processAllSteps(step.steps);
@@ -170,7 +234,7 @@ class PlaywrightPulseReporter {
         };
         let codeSnippet = undefined;
         try {
-            if (((_c = test.location) === null || _c === void 0 ? void 0 : _c.file) && ((_d = test.location) === null || _d === void 0 ? void 0 : _d.line) && ((_e = test.location) === null || _e === void 0 ? void 0 : _e.column)) {
+            if (((_b = test.location) === null || _b === void 0 ? void 0 : _b.file) && ((_c = test.location) === null || _c === void 0 ? void 0 : _c.line) && ((_d = test.location) === null || _d === void 0 ? void 0 : _d.column)) {
                 const relativePath = path.relative(this.config.rootDir, test.location.file);
                 codeSnippet = `Test defined at: ${relativePath}:${test.location.line}:${test.location.column}`;
             }
@@ -178,55 +242,145 @@ class PlaywrightPulseReporter {
         catch (e) {
             console.warn(`Pulse Reporter: Could not extract code snippet for ${test.title}`, e);
         }
-        const stdoutMessages = [];
-        if (result.stdout && result.stdout.length > 0) {
-            result.stdout.forEach((item) => {
-                stdoutMessages.push(typeof item === "string" ? item : item.toString());
-            });
-        }
-        const stderrMessages = [];
-        if (result.stderr && result.stderr.length > 0) {
-            result.stderr.forEach((item) => {
-                stderrMessages.push(typeof item === "string" ? item : item.toString());
-            });
-        }
-        const uniqueTestId = test.id;
+        const stdoutMessages = result.stdout.map((item) => typeof item === "string" ? item : item.toString());
+        const stderrMessages = result.stderr.map((item) => typeof item === "string" ? item : item.toString());
+        const maxWorkers = this.config.workers;
+        let mappedWorkerId = result.workerIndex === -1
+            ? -1
+            : (result.workerIndex % (maxWorkers > 0 ? maxWorkers : 1)) + 1;
+        const testSpecificData = {
+            workerId: mappedWorkerId,
+            totalWorkers: maxWorkers,
+            configFile: this.config.configFile,
+            metadata: this.config.metadata
+                ? JSON.stringify(this.config.metadata)
+                : undefined,
+        };
+        // Correctly handle the ID for each run. A unique ID per attempt is crucial.
+        const testIdWithRunCounter = `${test.id}-run-${result.retry}`;
         const pulseResult = {
-            id: uniqueTestId,
-            runId: "TBD",
+            id: testIdWithRunCounter, // Use the modified ID
+            runId: this.currentRunId, // Assign the overall run ID
             name: test.titlePath().join(" > "),
-            suiteName: (project === null || project === void 0 ? void 0 : project.name) || ((_f = this.config.projects[0]) === null || _f === void 0 ? void 0 : _f.name) || "Default Suite",
+            suiteName: (project === null || project === void 0 ? void 0 : project.name) || ((_e = this.config.projects[0]) === null || _e === void 0 ? void 0 : _e.name) || "Default Suite",
             status: testStatus,
             duration: result.duration,
             startTime: startTime,
             endTime: endTime,
-            browser: browserName,
-            retries: result.retry,
-            steps: ((_g = result.steps) === null || _g === void 0 ? void 0 : _g.length) ? await processAllSteps(result.steps) : [],
-            errorMessage: (_h = result.error) === null || _h === void 0 ? void 0 : _h.message,
-            stackTrace: (_j = result.error) === null || _j === void 0 ? void 0 : _j.stack,
+            browser: browserDetails,
+            retries: result.retry, // This is the Playwright retry count (0 for first run, 1 for first retry, etc.)
+            runCounter: result.retry, // This is your 'runCounter'
+            steps: ((_f = result.steps) === null || _f === void 0 ? void 0 : _f.length) ? await processAllSteps(result.steps) : [],
+            errorMessage: (_g = result.error) === null || _g === void 0 ? void 0 : _g.message,
+            stackTrace: (_h = result.error) === null || _h === void 0 ? void 0 : _h.stack,
+            snippet: (_j = result.error) === null || _j === void 0 ? void 0 : _j.snippet,
             codeSnippet: codeSnippet,
             tags: test.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
             screenshots: [],
-            videoPath: undefined,
+            videoPath: [],
             tracePath: undefined,
+            attachments: [],
             stdout: stdoutMessages.length > 0 ? stdoutMessages : undefined,
             stderr: stderrMessages.length > 0 ? stderrMessages : undefined,
+            ...testSpecificData,
         };
-        try {
-            (0, attachment_utils_1.attachFiles)(testIdForFiles, result, pulseResult, this.options);
+        for (const [index, attachment] of result.attachments.entries()) {
+            if (!attachment.path)
+                continue;
+            try {
+                // Use the new testIdWithRunCounter for the subfolder
+                const testSubfolder = testIdWithRunCounter.replace(/[^a-zA-Z0-9_-]/g, "_");
+                const safeAttachmentName = path
+                    .basename(attachment.path)
+                    .replace(/[^a-zA-Z0-9_.-]/g, "_");
+                const uniqueFileName = `${index}-${Date.now()}-${safeAttachmentName}`;
+                const relativeDestPath = path.join(ATTACHMENTS_SUBDIR, testSubfolder, uniqueFileName);
+                const absoluteDestPath = path.join(this.outputDir, relativeDestPath);
+                await this._ensureDirExists(path.dirname(absoluteDestPath));
+                await fs.copyFile(attachment.path, absoluteDestPath);
+                if (attachment.contentType.startsWith("image/")) {
+                    (_k = pulseResult.screenshots) === null || _k === void 0 ? void 0 : _k.push(relativeDestPath);
+                }
+                else if (attachment.contentType.startsWith("video/")) {
+                    (_l = pulseResult.videoPath) === null || _l === void 0 ? void 0 : _l.push(relativeDestPath);
+                }
+                else if (attachment.name === "trace") {
+                    pulseResult.tracePath = relativeDestPath;
+                }
+                else {
+                    (_m = pulseResult.attachments) === null || _m === void 0 ? void 0 : _m.push({
+                        name: attachment.name,
+                        path: relativeDestPath,
+                        contentType: attachment.contentType,
+                    });
+                }
+            }
+            catch (err) {
+                console.error(`Pulse Reporter: Failed to process attachment "${attachment.name}" for test ${pulseResult.name}. Error: ${err.message}`);
+            }
         }
-        catch (attachError) {
-            console.error(`Pulse Reporter: Error processing attachments for test ${pulseResult.name} (ID: ${testIdForFiles}): ${attachError.message}`);
+        this.results.push(pulseResult);
+    }
+    // New method to extract the base test ID, ignoring the run-counter suffix
+    _getBaseTestId(testResultId) {
+        const parts = testResultId.split("-run-");
+        return parts[0];
+    }
+    _getFinalizedResults(allResults) {
+        const finalResultsMap = new Map();
+        const allRunsMap = new Map();
+        // First, group all run attempts by their base test ID
+        for (const result of allResults) {
+            const baseTestId = this._getBaseTestId(result.id);
+            if (!allRunsMap.has(baseTestId)) {
+                allRunsMap.set(baseTestId, []);
+            }
+            allRunsMap.get(baseTestId).push(result);
         }
-        const existingTestIndex = this.results.findIndex((r) => r.id === uniqueTestId);
-        if (existingTestIndex !== -1) {
-            if (pulseResult.retries >= this.results[existingTestIndex].retries) {
-                this.results[existingTestIndex] = pulseResult;
+        // Now, iterate through the grouped runs to determine the final state
+        for (const [baseTestId, runs] of allRunsMap.entries()) {
+            let finalResult = undefined;
+            // Sort runs to process them in chronological order
+            runs.sort((a, b) => a.runCounter - b.runCounter);
+            for (const currentRun of runs) {
+                if (!finalResult) {
+                    finalResult = currentRun;
+                }
+                else {
+                    // Compare the current run to the best result found so far
+                    const currentStatusOrder = this._getStatusOrder(currentRun.status);
+                    const finalStatusOrder = this._getStatusOrder(finalResult.status);
+                    if (currentStatusOrder < finalStatusOrder) {
+                        // Current run is "better" (e.g., passed over failed)
+                        finalResult = currentRun;
+                    }
+                    else if (currentStatusOrder === finalStatusOrder &&
+                        currentRun.retries > finalResult.retries) {
+                        // Same status, but prefer the latest attempt
+                        finalResult = currentRun;
+                    }
+                }
+            }
+            if (finalResult) {
+                // Ensure the ID of the final result is the base test ID for de-duplication
+                finalResult.id = baseTestId;
+                finalResultsMap.set(baseTestId, finalResult);
             }
         }
-        else {
-            this.results.push(pulseResult);
+        return Array.from(finalResultsMap.values());
+    }
+    _getStatusOrder(status) {
+        switch (status) {
+            case "passed":
+                return 1;
+            case "flaky":
+                return 2;
+            case "failed":
+                return 3;
+            case "skipped":
+                return 4;
+            default:
+                return 99; // Unknown status
         }
     }
     onError(error) {
@@ -236,6 +390,20 @@ class PlaywrightPulseReporter {
             console.error(error.stack);
         }
     }
+    _getEnvDetails() {
+        return {
+            host: os.hostname(),
+            os: `${os.platform()} ${os.release()}`,
+            cpu: {
+                model: os.cpus()[0] ? os.cpus()[0].model : "N/A",
+                cores: os.cpus().length,
+            },
+            memory: `${(os.totalmem() / 1024 ** 3).toFixed(2)}GB`,
+            node: process.version,
+            v8: process.versions.v8,
+            cwd: process.cwd(),
+        };
+    }
     async _writeShardResults() {
         if (this.shardIndex === undefined) {
             return;
@@ -249,15 +417,14 @@ class PlaywrightPulseReporter {
         }
     }
     async _mergeShardResults(finalRunData) {
-        let allShardProcessedResults = [];
+        let allShardRawResults = []; // Store raw results before final de-duplication
         const totalShards = this.config.shard ? this.config.shard.total : 1;
         for (let i = 0; i < totalShards; i++) {
             const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${i}.json`);
             try {
                 const content = await fs.readFile(tempFilePath, "utf-8");
                 const shardResults = JSON.parse(content);
-                allShardProcessedResults =
-                    allShardProcessedResults.concat(shardResults);
+                allShardRawResults = allShardRawResults.concat(shardResults);
             }
             catch (error) {
                 if ((error === null || error === void 0 ? void 0 : error.code) === "ENOENT") {
@@ -268,18 +435,14 @@ class PlaywrightPulseReporter {
                 }
             }
         }
-        let finalUniqueResultsMap = new Map();
-        for (const result of allShardProcessedResults) {
-            const existing = finalUniqueResultsMap.get(result.id);
-            if (!existing || result.retries >= existing.retries) {
-                finalUniqueResultsMap.set(result.id, result);
-            }
-        }
-        const finalResultsList = Array.from(finalUniqueResultsMap.values());
+        // Apply _getFinalizedResults after all raw shard results are collected
+        const finalResultsList = this._getFinalizedResults(allShardRawResults);
         finalResultsList.forEach((r) => (r.runId = finalRunData.id));
         finalRunData.passed = finalResultsList.filter((r) => r.status === "passed").length;
         finalRunData.failed = finalResultsList.filter((r) => r.status === "failed").length;
         finalRunData.skipped = finalResultsList.filter((r) => r.status === "skipped").length;
+        // Add flaky count
+        finalRunData.flaky = finalResultsList.filter((r) => r.status === "flaky").length;
         finalRunData.totalTests = finalResultsList.length;
         const reviveDates = (key, value) => {
             const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
@@ -322,131 +485,177 @@ class PlaywrightPulseReporter {
         }
     }
     async onEnd(result) {
-        var _a, _b, _c;
         if (this.shardIndex !== undefined) {
             await this._writeShardResults();
             return;
         }
+        // Now, `this.results` contains all individual run attempts.
+        // _getFinalizedResults will select the "best" run for each logical test.
+        const finalResults = this._getFinalizedResults(this.results);
         const runEndTime = Date.now();
         const duration = runEndTime - this.runStartTime;
-        const runId = `run-${this.runStartTime}-${(0, crypto_1.randomUUID)()}`;
+        // Use the stored overall runId
+        const runId = this.currentRunId;
+        const environmentDetails = this._getEnvDetails();
         const runData = {
             id: runId,
             timestamp: new Date(this.runStartTime),
-            totalTests: 0,
-            passed: 0,
-            failed: 0,
-            skipped: 0,
+            totalTests: finalResults.length,
+            passed: finalResults.filter((r) => r.status === "passed").length,
+            failed: finalResults.filter((r) => r.status === "failed").length,
+            skipped: finalResults.filter((r) => r.status === "skipped").length,
+            flaky: finalResults.filter((r) => r.status === "flaky").length, // Add flaky count
             duration,
+            environment: environmentDetails,
         };
-        let finalReport = undefined; // Initialize as undefined
+        // Ensure all final results have the correct overall runId
+        finalResults.forEach((r) => (r.runId = runId));
+        let finalReport = undefined;
         if (this.isSharded) {
+            // _mergeShardResults will now perform the final de-duplication across shards
             finalReport = await this._mergeShardResults(runData);
         }
         else {
-            this.results.forEach((r) => (r.runId = runId));
-            runData.passed = this.results.filter((r) => r.status === "passed").length;
-            runData.failed = this.results.filter((r) => r.status === "failed").length;
-            runData.skipped = this.results.filter((r) => r.status === "skipped").length;
-            runData.totalTests = this.results.length;
-            const reviveDates = (key, value) => {
-                const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
-                if (typeof value === "string" && isoDateRegex.test(value)) {
-                    const date = new Date(value);
-                    return !isNaN(date.getTime()) ? date : value;
-                }
-                return value;
-            };
-            const properlyTypedResults = JSON.parse(JSON.stringify(this.results), reviveDates);
             finalReport = {
                 run: runData,
-                results: properlyTypedResults,
+                results: finalResults, // Use the de-duplicated results for a non-sharded run
                 metadata: { generatedAt: new Date().toISOString() },
             };
         }
         if (!finalReport) {
             console.error("PlaywrightPulseReporter: CRITICAL - finalReport object was not generated. Cannot create summary.");
-            const errorSummary = `
-PlaywrightPulseReporter: Run Finished
------------------------------------------
-  Overall Status: ERROR (Report data missing)
-  Total Tests:    N/A
-  Passed:         N/A
-  Failed:         N/A
-  Skipped:        N/A
-  Duration:       N/A
------------------------------------------`;
-            if (this.printsToStdio()) {
-                console.log(errorSummary);
-            }
-            const errorReport = {
-                run: {
-                    id: runId,
-                    timestamp: new Date(this.runStartTime),
-                    totalTests: 0,
-                    passed: 0,
-                    failed: 0,
-                    skipped: 0,
-                    duration: duration,
-                },
-                results: [],
-                metadata: {
-                    generatedAt: new Date().toISOString(),
-                },
-            };
-            const finalOutputPathOnError = path.join(this.outputDir, this.baseOutputFile);
+            return;
+        }
+        const jsonReplacer = (key, value) => {
+            if (value instanceof Date)
+                return value.toISOString();
+            if (typeof value === "bigint")
+                return value.toString();
+            return value;
+        };
+        if (this.resetOnEachRun) {
+            const finalOutputPath = path.join(this.outputDir, this.baseOutputFile);
             try {
                 await this._ensureDirExists(this.outputDir);
-                await fs.writeFile(finalOutputPathOnError, JSON.stringify(errorReport, null, 2));
-                console.warn(`PlaywrightPulseReporter: Wrote an error report to ${finalOutputPathOnError} as finalReport was missing.`);
+                await fs.writeFile(finalOutputPath, JSON.stringify(finalReport, jsonReplacer, 2));
+                if (this.printsToStdio()) {
+                    console.log(`PlaywrightPulseReporter: JSON report written to ${finalOutputPath}`);
+                }
             }
-            catch (writeError) {
-                console.error(`PlaywrightPulseReporter: Failed to write error report: ${writeError.message}`);
+            catch (error) {
+                console.error(`Pulse Reporter: Failed to write final JSON report to ${finalOutputPath}. Error: ${error.message}`);
             }
-            return;
         }
-        const reportRunData = finalReport.run;
-        const finalRunStatus = ((_a = reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.failed) !== null && _a !== void 0 ? _a : 0) > 0
-            ? "failed"
-            : ((_b = reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.totalTests) !== null && _b !== void 0 ? _b : 0) === 0 && result.status !== "passed"
-                ? result.status === "interrupted"
-                    ? "interrupted"
-                    : "no tests or error"
-                : "passed";
-        const summary = `
-PlaywrightPulseReporter: Run Finished
------------------------------------------
-  Overall Status: ${finalRunStatus.toUpperCase()}
-  Total Tests:    ${(reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.totalTests) || 0}
-  Passed:         ${reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.passed}
-  Failed:         ${reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.failed}
-  Skipped:        ${reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.skipped}
-  Duration:       ${(((_c = reportRunData === null || reportRunData === void 0 ? void 0 : reportRunData.duration) !== null && _c !== void 0 ? _c : 0) / 1000).toFixed(2)}s 
------------------------------------------`;
-        if (this.printsToStdio()) {
-            console.log(summary);
+        else {
+            const pulseResultsDir = path.join(this.outputDir, INDIVIDUAL_REPORTS_SUBDIR);
+            const individualReportPath = path.join(pulseResultsDir, `playwright-pulse-report-${Date.now()}.json`);
+            try {
+                await this._ensureDirExists(pulseResultsDir);
+                await fs.writeFile(individualReportPath, JSON.stringify(finalReport, jsonReplacer, 2));
+                if (this.printsToStdio()) {
+                    console.log(`PlaywrightPulseReporter: Individual run report for merging written to ${individualReportPath}`);
+                }
+                await this._mergeAllRunReports();
+            }
+            catch (error) {
+                console.error(`Pulse Reporter: Failed to write or merge report. Error: ${error.message}`);
+            }
         }
+        if (this.isSharded) {
+            await this._cleanupTemporaryFiles();
+        }
+    }
+    async _mergeAllRunReports() {
+        const pulseResultsDir = path.join(this.outputDir, INDIVIDUAL_REPORTS_SUBDIR);
         const finalOutputPath = path.join(this.outputDir, this.baseOutputFile);
+        let reportFiles;
+        try {
+            const allFiles = await fs.readdir(pulseResultsDir);
+            reportFiles = allFiles.filter((file) => file.startsWith("playwright-pulse-report-") && file.endsWith(".json"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                if (this.printsToStdio()) {
+                    console.log(`Pulse Reporter: No individual reports directory found at ${pulseResultsDir}. Skipping merge.`);
+                }
+                return;
+            }
+            console.error(`Pulse Reporter: Error reading report directory ${pulseResultsDir}:`, error);
+            return;
+        }
+        if (reportFiles.length === 0) {
+            if (this.printsToStdio()) {
+                console.log("Pulse Reporter: No matching JSON report files found to merge.");
+            }
+            return;
+        }
+        const allResultsFromAllFiles = [];
+        let latestTimestamp = new Date(0);
+        let lastRunEnvironment = undefined;
+        // We can't simply sum durations across merged files, as the tests might overlap.
+        // The final duration will be derived from the range of start/end times in the final results.
+        let earliestStartTime = Date.now();
+        let latestEndTime = 0;
+        for (const file of reportFiles) {
+            const filePath = path.join(pulseResultsDir, file);
+            try {
+                const content = await fs.readFile(filePath, "utf-8");
+                const json = JSON.parse(content);
+                if (json.run) {
+                    const runTimestamp = new Date(json.run.timestamp);
+                    if (runTimestamp > latestTimestamp) {
+                        latestTimestamp = runTimestamp;
+                        lastRunEnvironment = json.run.environment || undefined;
+                    }
+                }
+                if (json.results) {
+                    allResultsFromAllFiles.push(...json.results);
+                }
+            }
+            catch (err) {
+                console.warn(`Pulse Reporter: Could not parse report file ${filePath}. Skipping. Error: ${err.message}`);
+            }
+        }
+        // De-duplicate the results from ALL merged files using the helper function
+        const finalMergedResults = this._getFinalizedResults(allResultsFromAllFiles);
+        // Calculate overall duration from the earliest start and latest end of the final merged results
+        for (const res of finalMergedResults) {
+            if (res.startTime.getTime() < earliestStartTime)
+                earliestStartTime = res.startTime.getTime();
+            if (res.endTime.getTime() > latestEndTime)
+                latestEndTime = res.endTime.getTime();
+        }
+        const totalDuration = latestEndTime > earliestStartTime ? latestEndTime - earliestStartTime : 0;
+        const combinedRun = {
+            id: `merged-${Date.now()}`,
+            timestamp: latestTimestamp,
+            environment: lastRunEnvironment,
+            totalTests: finalMergedResults.length,
+            passed: finalMergedResults.filter((r) => r.status === "passed").length,
+            failed: finalMergedResults.filter((r) => r.status === "failed").length,
+            skipped: finalMergedResults.filter((r) => r.status === "skipped").length,
+            flaky: finalMergedResults.filter((r) => r.status === "flaky").length, // Add flaky count
+            duration: totalDuration,
+        };
+        const finalReport = {
+            run: combinedRun,
+            results: finalMergedResults,
+            metadata: {
+                generatedAt: new Date().toISOString(),
+            },
+        };
         try {
-            await this._ensureDirExists(this.outputDir);
             await fs.writeFile(finalOutputPath, JSON.stringify(finalReport, (key, value) => {
                 if (value instanceof Date)
                     return value.toISOString();
-                if (typeof value === "bigint")
-                    return value.toString();
                 return value;
             }, 2));
             if (this.printsToStdio()) {
-                console.log(`PlaywrightPulseReporter: JSON report written to ${finalOutputPath}`);
+                console.log(`PlaywrightPulseReporter: ✅ Merged report with ${finalMergedResults.length} total results saved to ${finalOutputPath}`);
             }
         }
-        catch (error) {
-            console.error(`Pulse Reporter: Failed to write final JSON report to ${finalOutputPath}. Error: ${error.message}`);
-        }
-        finally {
-            if (this.isSharded) {
-                await this._cleanupTemporaryFiles();
-            }
+        catch (err) {
+            console.error(`Pulse Reporter: Failed to write final merged report to ${finalOutputPath}. Error: ${err.message}`);
         }
     }
 }