@arghajit/dummy 0.1.2-beta-11 → 0.1.3

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

@@ -1,66 +1,51 @@
 "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.PlaywrightPulseReporter = void 0;
-const fs = {
-    promises: {
-        writeFile: async (path, data) => {
-            console.log(`Would write to ${path}`);
-        },
-        readFile: async (path, encoding) => {
-            console.log(`Would read from ${path}`);
-            return "{}";
-        },
-        readdir: async (path) => {
-            console.log(`Would read directory ${path}`);
-            return [];
-        },
-        mkdir: async (path, options) => {
-            console.log(`Would create directory ${path}`);
-        },
-        unlink: async (path) => {
-            console.log(`Would delete ${path}`);
-        },
-    },
-};
-const path = {
-    resolve: (...paths) => paths.join("/"),
-    join: (...paths) => paths.join("/"),
-    relative: (from, to) => to,
-    dirname: (p) => p.split("/").slice(0, -1).join("/"),
-    basename: (p, ext) => {
-        const base = p.split("/").pop() || "";
-        return ext ? base.replace(ext, "") : base;
-    },
-    extname: (p) => {
-        const parts = p.split(".");
-        return parts.length > 1 ? "." + parts.pop() : "";
-    },
-};
-const randomUUID = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-    const r = (Math.random() * 16) | 0;
-    const v = c == "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-});
-const UAParser = class {
-    getBrowser() {
-        return { name: "unknown", version: "unknown" };
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const ua_parser_js_1 = require("ua-parser-js");
+const os = __importStar(require("os"));
+const convertStatus = (status, testCase) => {
+    if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "failed") {
+        return "failed";
+    }
+    if ((testCase === null || testCase === void 0 ? void 0 : testCase.expectedStatus) === "skipped") {
+        return "skipped";
     }
-};
-const os = {
-    type: () => "Linux",
-    release: () => "5.4.0",
-    arch: () => "x64",
-    hostname: () => "localhost",
-    platform: () => "linux",
-    cpus: () => [{ model: "Intel" }],
-    totalmem: () => 8589934592,
-};
-const process = {
-    cwd: () => "/current/working/directory",
-    version: "v18.0.0",
-    versions: { v8: "10.0.0" },
-};
-function convertStatus(status) {
     switch (status) {
         case "passed":
             return "passed";
@@ -69,429 +54,525 @@ function convertStatus(status) {
         case "interrupted":
             return "failed";
         case "skipped":
-            return "skipped";
         default:
-            return "failed";
+            return "skipped";
     }
-}
-function attachFiles(testId, pwResult, pulseResult, config) {
-    const baseReportDir = config.outputDir || "pulse-report";
-    const attachmentsBaseDir = path.resolve(baseReportDir, "attachments");
-    const attachmentsSubFolder = `${testId}-retry-${pwResult.retry || 0}`.replace(/[^a-zA-Z0-9_-]/g, "_");
-    pulseResult.screenshots = [];
-    pulseResult.videoPath = [];
-    pulseResult.attachments = [];
-    if (!pwResult.attachments)
-        return;
-    pwResult.attachments.forEach((attachment) => {
-        var _a, _b, _c;
-        const { contentType, name, path: attachmentPath } = attachment;
-        if (!attachmentPath)
-            return;
-        const relativePath = path.join("attachments", attachmentsSubFolder, path.basename(attachmentPath));
-        if (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith("image/")) {
-            (_a = pulseResult.screenshots) === null || _a === void 0 ? void 0 : _a.push(relativePath);
-        }
-        else if (name === "video" || (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith("video/"))) {
-            (_b = pulseResult.videoPath) === null || _b === void 0 ? void 0 : _b.push(relativePath);
-        }
-        else if (name === "trace" || contentType === "application/zip") {
-            pulseResult.tracePath = relativePath;
-        }
-        else {
-            (_c = pulseResult.attachments) === null || _c === void 0 ? void 0 : _c.push({
-                name: attachment.name,
-                path: relativePath,
-                contentType: attachment.contentType,
-            });
-        }
-    });
-}
+};
+const TEMP_SHARD_FILE_PREFIX = ".pulse-shard-results-";
+const ATTACHMENTS_SUBDIR = "attachments";
+const INDIVIDUAL_REPORTS_SUBDIR = "pulse-results";
 class PlaywrightPulseReporter {
     constructor(options = {}) {
-        this.testResults = [];
-        this.currentRunId = "";
-        this.outputDir = "";
-        this.totalWorkers = 0;
+        var _a, _b, _c;
+        this.results = [];
+        this.baseOutputFile = "playwright-pulse-report.json";
+        this.isSharded = false;
+        this.shardIndex = undefined;
         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 false;
+        return this.shardIndex === undefined || this.shardIndex === 0;
     }
     onBegin(config, suite) {
         var _a;
-        this.currentRunId = randomUUID();
-        this.totalWorkers = config.workers;
-        this.shardIndex = (_a = config.shard) === null || _a === void 0 ? void 0 : _a.current;
-        this.outputDir = path.resolve(this.options.outputDir || config.outputDir || "pulse-report");
-        if (this.options.open === undefined) {
-            this.options.open = false;
-        }
-        if (this.options.base64Images === undefined) {
-            this.options.base64Images = false;
+        this.config = config;
+        this.suite = suite;
+        this.runStartTime = Date.now();
+        const configDir = this.config.rootDir;
+        const configFileDir = this.config.configFile
+            ? path.dirname(this.config.configFile)
+            : configDir;
+        this.outputDir = path.resolve(configFileDir, (_a = this.options.outputDir) !== null && _a !== void 0 ? _a : "pulse-report");
+        this.attachmentsDir = path.resolve(this.outputDir, ATTACHMENTS_SUBDIR);
+        this.options.outputDir = this.outputDir;
+        const totalShards = this.config.shard ? this.config.shard.total : 1;
+        this.isSharded = totalShards > 1;
+        this.shardIndex = this.config.shard
+            ? this.config.shard.current - 1
+            : undefined;
+        this._ensureDirExists(this.outputDir)
+            .then(() => {
+            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)) {
+                    return this._cleanupTemporaryFiles();
+                }
+            }
+        })
+            .catch((err) => console.error("Pulse Reporter: Error during initialization:", err));
+    }
+    onTestBegin(test) {
+        console.log(`Starting test: ${test.title}`);
+    }
+    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}`;
         }
-        console.log(`Pulse Reporter: Starting test run with ID: ${this.currentRunId}`);
-        if (this.shardIndex !== undefined) {
-            console.log(`Pulse Reporter: Running shard ${this.shardIndex}`);
+        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();
     }
-    getBrowserDetails(project) {
-        var _a, _b;
-        if (!project)
-            return "unknown";
-        const projectName = project.name || "unknown";
-        const browserName = ((_a = project.use) === null || _a === void 0 ? void 0 : _a.browserName) || "unknown";
-        const channel = (_b = project.use) === null || _b === void 0 ? void 0 : _b.channel;
-        if (channel) {
-            return `${browserName}-${channel}`;
+    async processStep(step, testId, browserDetails, testCase) {
+        var _a, _b, _c, _d;
+        let stepStatus = "passed";
+        let errorMessage = ((_a = step.error) === null || _a === void 0 ? void 0 : _a.message) || undefined;
+        if ((_c = (_b = step.error) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.startsWith("Test is skipped:")) {
+            stepStatus = "skipped";
+        }
+        else {
+            stepStatus = convertStatus(step.error ? "failed" : "passed", testCase);
+        }
+        const duration = step.duration;
+        const startTime = new Date(step.startTime);
+        const endTime = new Date(startTime.getTime() + Math.max(0, duration));
+        let codeLocation = "";
+        if (step.location) {
+            codeLocation = `${path.relative(this.config.rootDir, step.location.file)}:${step.location.line}:${step.location.column}`;
         }
-        return browserName;
-    }
-    async processStep(step) {
-        const stepStatus = convertStatus(step.error ? "failed" : "passed");
-        const codeLocation = step.location
-            ? `${step.location.file}:${step.location.line}:${step.location.column}`
-            : undefined;
         return {
+            id: `${testId}_step_${startTime.toISOString()}-${duration}-${(0, crypto_1.randomUUID)()}`,
             title: step.title,
-            category: step.category,
-            startTime: step.startTime,
-            duration: step.duration,
-            error: step.error
-                ? {
-                    message: step.error.message || "",
-                    stack: step.error.stack,
-                    snippet: step.error.snippet,
-                }
-                : undefined,
-            count: step.count || 0,
-            location: codeLocation,
             status: stepStatus,
+            duration: duration,
+            startTime: startTime,
+            endTime: endTime,
+            browser: browserDetails,
+            errorMessage: errorMessage,
+            stackTrace: ((_d = step.error) === null || _d === void 0 ? void 0 : _d.stack) || undefined,
+            codeLocation: codeLocation || undefined,
+            isHook: step.category === "hook",
+            hookType: step.category === "hook"
+                ? step.title.toLowerCase().includes("before")
+                    ? "before"
+                    : "after"
+                : undefined,
+            steps: [],
         };
     }
     async onTestEnd(test, result) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        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 browserDetails = this.getBrowserDetails(test);
+        const testStatus = convertStatus(result.status, test);
+        const startTime = new Date(result.startTime);
+        const endTime = new Date(startTime.getTime() + result.duration);
         const processAllSteps = async (steps) => {
-            const processedSteps = [];
+            let processed = [];
             for (const step of steps) {
-                const processedStep = await this.processStep(step);
-                processedSteps.push(processedStep);
+                const processedStep = await this.processStep(step, test.id, browserDetails, test);
+                processed.push(processedStep);
                 if (step.steps && step.steps.length > 0) {
-                    const nestedSteps = await processAllSteps(step.steps);
-                    processedSteps.push(...nestedSteps);
+                    processedStep.steps = await processAllSteps(step.steps);
                 }
             }
-            return processedSteps;
+            return processed;
         };
-        const project = (_b = (_a = test.parent) === null || _a === void 0 ? void 0 : _a.project) === null || _b === void 0 ? void 0 : _b.call(_a);
-        const relativePath = path.relative(process.cwd(), ((_c = test.location) === null || _c === void 0 ? void 0 : _c.file) || "");
-        const testStatus = convertStatus(result.status);
-        const startTime = result.startTime;
-        const endTime = new Date(startTime.getTime() + result.duration);
-        const stdoutMessages = result.stdout
-            .filter((msg) => msg.trim().length > 0)
-            .map((msg) => msg.toString());
-        const stderrMessages = result.stderr
-            .filter((msg) => msg.trim().length > 0)
-            .map((msg) => msg.toString());
-        const mappedWorkerId = result.workerIndex !== undefined ? result.workerIndex + 1 : undefined;
+        let codeSnippet = undefined;
+        try {
+            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}`;
+            }
+        }
+        catch (e) {
+            console.warn(`Pulse Reporter: Could not extract code snippet for ${test.title}`, e);
+        }
+        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: this.totalWorkers,
-            configFile: relativePath,
-            metadata: JSON.stringify({ project: project === null || project === void 0 ? void 0 : project.name }),
+            totalWorkers: maxWorkers,
+            configFile: this.config.configFile,
+            metadata: this.config.metadata
+                ? JSON.stringify(this.config.metadata)
+                : undefined,
         };
         const pulseResult = {
             id: test.id,
-            runId: this.currentRunId,
-            name: `${(project === null || project === void 0 ? void 0 : project.name) || "unknown"} > ${((_d = test.parent) === null || _d === void 0 ? void 0 : _d.title) || ""} > ${test.title}`,
-            suiteName: project === null || project === void 0 ? void 0 : project.name,
+            runId: "TBD",
+            name: test.titlePath().join(" > "),
+            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,
-            retry: result.retry,
-            steps: await processAllSteps(result.steps),
-            errorMessage: (_e = result.error) === null || _e === void 0 ? void 0 : _e.message,
-            stackTrace: (_f = result.error) === null || _f === void 0 ? void 0 : _f.stack,
-            snippet: (_g = result.error) === null || _g === void 0 ? void 0 : _g.snippet,
-            codeSnippet: (_h = result.error) === null || _h === void 0 ? void 0 : _h.snippet,
-            tags: test.tags,
-            browser: this.getBrowserDetails(project),
+            browser: browserDetails,
+            retries: result.retry,
+            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: [],
+            tracePath: undefined,
             attachments: [],
-            stdout: stdoutMessages,
-            stderr: stderrMessages,
+            stdout: stdoutMessages.length > 0 ? stdoutMessages : undefined,
+            stderr: stderrMessages.length > 0 ? stderrMessages : undefined,
             ...testSpecificData,
         };
-        attachFiles(test.id, result, pulseResult, this.options);
-        this.testResults.push(pulseResult);
-    }
-    _getFinalizedResults(allAttempts) {
-        const groupedResults = new Map();
-        for (const attempt of allAttempts) {
-            const baseTestId = attempt.id;
-            if (!groupedResults.has(baseTestId)) {
-                groupedResults.set(baseTestId, []);
-            }
-            groupedResults.get(baseTestId).push(attempt);
-        }
-        const finalResults = [];
-        for (const [baseId, attempts] of groupedResults.entries()) {
-            attempts.sort((a, b) => a.retry - b.retry);
-            let overallStatus = "passed";
-            const statuses = attempts.map((a) => a.status);
-            const hasFailures = statuses.some((s) => s === "failed");
-            const hasPasses = statuses.some((s) => s === "passed");
-            if (hasFailures && hasPasses) {
-                overallStatus = "flaky";
-            }
-            else if (hasFailures) {
-                overallStatus = "failed";
-            }
-            else if (statuses.some((s) => s === "skipped")) {
-                overallStatus = "skipped";
+        for (const [index, attachment] of result.attachments.entries()) {
+            if (!attachment.path)
+                continue;
+            try {
+                const testSubfolder = test.id.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,
+                    });
+                }
             }
-            else {
-                overallStatus = "passed";
+            catch (err) {
+                console.error(`Pulse Reporter: Failed to process attachment "${attachment.name}" for test ${pulseResult.name}. Error: ${err.message}`);
             }
-            const startTimes = attempts.map((a) => a.startTime.getTime());
-            const endTimes = attempts.map((a) => a.endTime.getTime());
-            const overallDuration = Math.max(...endTimes) - Math.min(...startTimes);
-            const baseAttempt = attempts[0];
-            finalResults.push({
-                id: baseId,
-                name: baseAttempt.name,
-                suiteName: baseAttempt.suiteName,
-                status: overallStatus,
-                duration: overallDuration,
-                startTime: new Date(Math.min(...startTimes)),
-                endTime: new Date(Math.max(...endTimes)),
-                browser: baseAttempt.browser,
-                tags: baseAttempt.tags,
-                results: attempts,
-            });
         }
-        return finalResults;
+        this.results.push(pulseResult);
     }
-    _getSummaryStats(consolidatedResults) {
-        let passed = 0;
-        let failed = 0;
-        let skipped = 0;
-        let flaky = 0;
-        for (const result of consolidatedResults) {
-            switch (result.status) {
-                case "passed":
-                    passed++;
-                    break;
-                case "failed":
-                    failed++;
-                    break;
-                case "skipped":
-                    skipped++;
-                    break;
-                case "flaky":
-                    flaky++;
-                    break;
+    _getFinalizedResults(allResults) {
+        const finalResultsMap = new Map();
+        for (const result of allResults) {
+            const existing = finalResultsMap.get(result.id);
+            // Keep the result with the highest retry attempt for each test ID
+            if (!existing || result.retries >= existing.retries) {
+                finalResultsMap.set(result.id, result);
             }
         }
-        return {
-            passed,
-            failed,
-            skipped,
-            flaky,
-            totalTests: consolidatedResults.length,
-        };
-    }
-    _getSummaryStatsFromAttempts(attempts) {
-        let passed = 0;
-        let failed = 0;
-        let skipped = 0;
-        let flaky = 0;
-        const groupedByTest = new Map();
-        for (const attempt of attempts) {
-            const baseId = attempt.id.replace(/-\d+$/, "");
-            if (!groupedByTest.has(baseId)) {
-                groupedByTest.set(baseId, []);
-            }
-            groupedByTest.get(baseId).push(attempt);
-        }
-        for (const attempt of attempts) {
-            const baseId = attempt.id.replace(/-\d+$/, "");
-            const testAttempts = groupedByTest.get(baseId);
-            const hasFailures = testAttempts.some((a) => a.status === "failed");
-            const hasPasses = testAttempts.some((a) => a.status === "passed");
-            if (hasFailures && hasPasses) {
-                flaky++;
-            }
-            else {
-                switch (attempt.status) {
-                    case "passed":
-                        passed++;
-                        break;
-                    case "failed":
-                        failed++;
-                        break;
-                    case "skipped":
-                        skipped++;
-                        break;
-                }
-            }
-        }
-        return {
-            passed,
-            failed,
-            skipped,
-            flaky,
-            totalTests: attempts.length,
-        };
+        return Array.from(finalResultsMap.values());
     }
     onError(error) {
-        console.error("Pulse Reporter: Error occurred:", error);
+        var _a;
+        console.error(`PlaywrightPulseReporter: Error encountered (Shard: ${(_a = this.shardIndex) !== null && _a !== void 0 ? _a : "Main"}):`, (error === null || error === void 0 ? void 0 : error.message) || error);
+        if (error === null || error === void 0 ? void 0 : error.stack) {
+            console.error(error.stack);
+        }
     }
     _getEnvDetails() {
-        const parser = new UAParser();
         return {
-            os: `${os.type()} ${os.release()}`,
-            browser: parser.getBrowser(),
-            cpu: os.arch(),
+            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(individualResults) {
-        const tempFilePath = path.join(this.outputDir, `shard-${this.shardIndex || 0}-results.json`);
+    async _writeShardResults() {
+        if (this.shardIndex === undefined) {
+            return;
+        }
+        const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${this.shardIndex}.json`);
         try {
-            await this._ensureDirExists(path.dirname(tempFilePath));
-            await fs.promises.writeFile(tempFilePath, JSON.stringify(individualResults, null, 2));
+            await fs.writeFile(tempFilePath, JSON.stringify(this.results, (key, value) => (value instanceof Date ? value.toISOString() : value), 2));
         }
         catch (error) {
-            console.error("Pulse Reporter: Error writing shard results:", error);
+            console.error(`Pulse Reporter: Shard ${this.shardIndex} failed to write temporary results to ${tempFilePath}`, error);
         }
     }
-    async _mergeShardResults(allShardResults) {
-        try {
-            const allAttempts = allShardResults.flat();
-            const reviveDates = (key, value) => {
-                if (typeof value === "string" &&
-                    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
-                    return new Date(value);
+    async _mergeShardResults(finalRunData) {
+        let allShardProcessedResults = [];
+        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);
+            }
+            catch (error) {
+                if ((error === null || error === void 0 ? void 0 : error.code) === "ENOENT") {
+                    console.warn(`Pulse Reporter: Shard results file not found: ${tempFilePath}. This might be normal if a shard had no tests or failed early.`);
                 }
-                return value;
-            };
-            const properlyTypedResults = JSON.parse(JSON.stringify(allAttempts), reviveDates);
-            return properlyTypedResults;
-        }
-        catch (error) {
-            console.error("Pulse Reporter: Error merging shard results:", error);
-            return [];
+                else {
+                    console.error(`Pulse Reporter: Could not read/parse results from shard ${i} (${tempFilePath}). Error:`, error);
+                }
+            }
         }
+        const finalResultsList = this._getFinalizedResults(allShardProcessedResults);
+        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;
+        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$/;
+            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(finalResultsList), reviveDates);
+        return {
+            run: finalRunData,
+            results: properlyTypedResults,
+            metadata: { generatedAt: new Date().toISOString() },
+        };
     }
     async _cleanupTemporaryFiles() {
         try {
-            const files = await fs.promises.readdir(this.outputDir);
-            const shardFiles = files.filter((file) => file.startsWith("shard-") && file.endsWith("-results.json"));
-            for (const file of shardFiles) {
-                await fs.promises.unlink(path.join(this.outputDir, file));
+            const files = await fs.readdir(this.outputDir);
+            const tempFiles = files.filter((f) => f.startsWith(TEMP_SHARD_FILE_PREFIX));
+            if (tempFiles.length > 0) {
+                await Promise.all(tempFiles.map((f) => fs.unlink(path.join(this.outputDir, f))));
             }
         }
         catch (error) {
-            console.error("Pulse Reporter: Error cleaning up temporary files:", error);
+            if ((error === null || error === void 0 ? void 0 : error.code) !== "ENOENT") {
+                console.warn("Pulse Reporter: Warning during cleanup of temporary files:", error.message);
+            }
         }
     }
     async _ensureDirExists(dirPath) {
         try {
-            await fs.promises.mkdir(dirPath, { recursive: true });
+            await fs.mkdir(dirPath, { recursive: true });
         }
         catch (error) {
-            console.error(`Pulse Reporter: Error creating directory ${dirPath}:`, error);
+            if (error.code !== "EEXIST") {
+                console.error(`Pulse Reporter: Failed to ensure directory exists: ${dirPath}`, error);
+                throw error;
+            }
         }
     }
     async onEnd(result) {
-        try {
-            const individualResults = this.testResults;
-            const stats = this._getSummaryStatsFromAttempts(individualResults);
-            const runData = {
-                id: this.currentRunId,
-                startTime: new Date(),
-                endTime: new Date(),
-                duration: result.duration,
-                status: result.status,
-                environment: this._getEnvDetails(),
-            };
-            const finalReport = {
+        if (this.shardIndex !== undefined) {
+            await this._writeShardResults();
+            return;
+        }
+        // De-duplicate and handle retries here, in a safe, single-threaded context.
+        const finalResults = this._getFinalizedResults(this.results);
+        const runEndTime = Date.now();
+        const duration = runEndTime - this.runStartTime;
+        const runId = `run-${this.runStartTime}-581d5ad8-ce75-4ca5-94a6-ed29c466c815`;
+        const environmentDetails = this._getEnvDetails();
+        const runData = {
+            id: runId,
+            timestamp: new Date(this.runStartTime),
+            // Use the length of the de-duplicated array for all counts
+            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,
+            duration,
+            environment: environmentDetails,
+        };
+        finalResults.forEach((r) => (r.runId = runId));
+        let finalReport = undefined;
+        if (this.isSharded) {
+            // The _mergeShardResults method will handle its own de-duplication
+            finalReport = await this._mergeShardResults(runData);
+        }
+        else {
+            finalReport = {
                 run: runData,
-                results: individualResults,
-                summary: stats,
+                // Use the de-duplicated results
+                results: finalResults,
+                metadata: { generatedAt: new Date().toISOString() },
             };
-            const jsonReplacer = (key, value) => {
-                if (value instanceof Date) {
-                    return value.toISOString();
+        }
+        if (!finalReport) {
+            console.error("PlaywrightPulseReporter: CRITICAL - finalReport object was not generated. Cannot create summary.");
+            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(finalOutputPath, JSON.stringify(finalReport, jsonReplacer, 2));
+                if (this.printsToStdio()) {
+                    console.log(`PlaywrightPulseReporter: JSON report written to ${finalOutputPath}`);
                 }
-                return value;
-            };
-            if (this.shardIndex !== undefined) {
-                await this._writeShardResults(individualResults);
-                console.log(`Pulse Reporter: Shard ${this.shardIndex} results written.`);
             }
-            else {
-                const pulseResultsDir = path.join(this.outputDir, "pulse-results");
+            catch (error) {
+                console.error(`Pulse Reporter: Failed to write final JSON report to ${finalOutputPath}. Error: ${error.message}`);
+            }
+        }
+        else {
+            // Logic for appending/merging reports
+            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);
-                const individualReportPath = path.join(pulseResultsDir, `${this.currentRunId}-pulse-report.json`);
-                await fs.promises.writeFile(individualReportPath, JSON.stringify(finalReport, jsonReplacer, 2));
-                const mergedReport = await this._mergeAllRunReports();
-                if (mergedReport) {
-                    const finalReportPath = path.join(this.outputDir, "playwright-pulse-report.json");
-                    await fs.promises.writeFile(finalReportPath, JSON.stringify(mergedReport, jsonReplacer, 2));
-                    console.log(`Pulse Reporter: Final report written to ${finalReportPath}`);
+                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}`);
             }
         }
-        catch (error) {
-            console.error("Pulse Reporter: Error in onEnd:", error);
+        if (this.isSharded) {
+            await this._cleanupTemporaryFiles();
         }
     }
     async _mergeAllRunReports() {
-        var _a;
+        const pulseResultsDir = path.join(this.outputDir, INDIVIDUAL_REPORTS_SUBDIR);
+        const finalOutputPath = path.join(this.outputDir, this.baseOutputFile);
+        let reportFiles;
         try {
-            const pulseResultsDir = path.join(this.outputDir, "pulse-results");
-            const files = await fs.promises.readdir(pulseResultsDir);
-            const jsonFiles = files.filter((file) => file.endsWith("-pulse-report.json"));
-            if (jsonFiles.length === 0) {
-                return null;
+            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;
             }
-            const allAttempts = [];
-            let totalDuration = 0;
-            for (const file of jsonFiles) {
-                const filePath = path.join(pulseResultsDir, file);
-                const content = await fs.promises.readFile(filePath, "utf-8");
-                const report = JSON.parse(content);
-                if (report.results) {
-                    allAttempts.push(...report.results);
+            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;
+        let totalDuration = 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 ((_a = report.run) === null || _a === void 0 ? void 0 : _a.duration) {
-                    totalDuration += report.run.duration;
+                if (json.results) {
+                    allResultsFromAllFiles.push(...json.results);
                 }
             }
-            const stats = this._getSummaryStatsFromAttempts(allAttempts);
-            const combinedRun = {
-                id: this.currentRunId,
-                startTime: new Date(),
-                endTime: new Date(),
-                duration: totalDuration,
-                status: "passed",
-                environment: this._getEnvDetails(),
-            };
-            const finalReport = {
-                run: combinedRun,
-                results: allAttempts,
-                summary: stats,
-            };
-            return finalReport;
+            catch (err) {
+                console.warn(`Pulse Reporter: Could not parse report file ${filePath}. Skipping. Error: ${err.message}`);
+            }
         }
-        catch (error) {
-            console.error("Pulse Reporter: Error merging all run reports:", error);
-            return null;
+        // De-duplicate the results from ALL merged files using the helper function
+        const finalMergedResults = this._getFinalizedResults(allResultsFromAllFiles);
+        // Sum the duration from the final, de-duplicated list of tests
+        totalDuration = finalMergedResults.reduce((acc, r) => acc + (r.duration || 0), 0);
+        const combinedRun = {
+            id: `merged-${Date.now()}`,
+            timestamp: latestTimestamp,
+            environment: lastRunEnvironment,
+            // Recalculate counts based on the truly final, de-duplicated list
+            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,
+            duration: totalDuration,
+        };
+        const finalReport = {
+            run: combinedRun,
+            results: finalMergedResults, // Use the de-duplicated list
+            metadata: {
+                generatedAt: new Date().toISOString(),
+            },
+        };
+        try {
+            await fs.writeFile(finalOutputPath, JSON.stringify(finalReport, (key, value) => {
+                if (value instanceof Date)
+                    return value.toISOString();
+                return value;
+            }, 2));
+            if (this.printsToStdio()) {
+                console.log(`PlaywrightPulseReporter: ✅ Merged report with ${finalMergedResults.length} total results saved to ${finalOutputPath}`);
+            }
+        }
+        catch (err) {
+            console.error(`Pulse Reporter: Failed to write final merged report to ${finalOutputPath}. Error: ${err.message}`);
         }
     }
 }
 exports.PlaywrightPulseReporter = PlaywrightPulseReporter;
+exports.default = PlaywrightPulseReporter;