@arghajit/dummy 0.3.38 → 0.3.39

package/dist/reporter/playwright-pulse-reporter.d.ts

@@ -10,6 +10,7 @@ export declare class PlaywrightPulseReporter implements Reporter {
     private outputDir;
     private attachmentsDir;
     private baseOutputFile;
+    private individualReportsSubDir;
     private isSharded;
     private shardIndex;
     private resetOnEachRun;
@@ -46,6 +47,5 @@ export declare class PlaywrightPulseReporter implements Reporter {
     private _cleanupStaleRunReports;
     private _ensureDirExists;
     onEnd(result: FullResult): Promise<void>;
-    private _mergeAllRunReports;
 }
 export default PlaywrightPulseReporter;

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

@@ -64,20 +64,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, _c;
+        var _a, _b, _c, _d;
         this.results = [];
         this._pendingTestEnds = [];
         this.baseOutputFile = "playwright-pulse-report.json";
+        this.individualReportsSubDir = "pulse-results";
         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.individualReportsSubDir = (_c = options.individualReportsSubDir) !== null && _c !== void 0 ? _c : "pulse-results";
         this.attachmentsDir = path.join(this.outputDir, ATTACHMENTS_SUBDIR);
-        this.resetOnEachRun = (_c = options.resetOnEachRun) !== null && _c !== void 0 ? _c : true;
+        this.resetOnEachRun = (_d = options.resetOnEachRun) !== null && _d !== void 0 ? _d : true;
     }
     printsToStdio() {
         return this.shardIndex === undefined || this.shardIndex === 0;
@@ -524,7 +525,7 @@ class PlaywrightPulseReporter {
      * Cleaning up at `onBegin` time guarantees each run starts with a fresh slate.
      */
     async _cleanupStaleRunReports() {
-        const pulseResultsDir = path.join(this.outputDir, INDIVIDUAL_REPORTS_SUBDIR);
+        const pulseResultsDir = path.join(this.outputDir, this.individualReportsSubDir);
         try {
             const files = await fs.readdir(pulseResultsDir);
             const staleFiles = files.filter((f) => f.startsWith("playwright-pulse-report-") && f.endsWith(".json"));
@@ -625,7 +626,7 @@ class PlaywrightPulseReporter {
         }
         else {
             // Logic for appending/merging reports
-            const pulseResultsDir = path.join(this.outputDir, INDIVIDUAL_REPORTS_SUBDIR);
+            const pulseResultsDir = path.join(this.outputDir, this.individualReportsSubDir);
             const individualReportPath = path.join(pulseResultsDir, `playwright-pulse-report-${Date.now()}.json`);
             try {
                 await this._ensureDirExists(pulseResultsDir);
@@ -633,111 +634,19 @@ class PlaywrightPulseReporter {
                 if (this.printsToStdio()) {
                     console.log(`PlaywrightPulseReporter: Individual run report for merging written to ${individualReportPath}`);
                 }
-                await this._mergeAllRunReports();
+                // DEFERRED MERGING: 
+                // We do not call _mergeAllRunReports() here anymore when resetOnEachRun is false.
+                // The individual JSON files in pulse-results/ will be collected and merged
+                // into the main JSON when the user next runs one of the report generator commands.
             }
             catch (error) {
-                console.error(`Pulse Reporter: Failed to write or merge report. Error: ${error.message}`);
+                console.error(`Pulse Reporter: Failed to write 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;
-        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 (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);
-        // 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.final_status || r.status) === "passed").length,
-            failed: finalMergedResults.filter((r) => (r.final_status || r.status) === "failed").length,
-            skipped: finalMergedResults.filter((r) => (r.final_status || r.status) === "skipped").length,
-            flaky: finalMergedResults.filter((r) => (r.final_status || r.status) === "flaky").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}`);
-            }
-            // Clean up the pulse-results directory after a successful merge
-            try {
-                await fs.rm(pulseResultsDir, { recursive: true, force: true });
-                if (this.printsToStdio()) {
-                    console.log(`PlaywrightPulseReporter: Cleaned up individual reports directory at ${pulseResultsDir}`);
-                }
-            }
-            catch (cleanupErr) {
-                console.warn(`Pulse Reporter: Could not clean up individual reports directory. Error: ${cleanupErr.message}`);
-            }
-        }
-        catch (err) {
-            console.error(`Pulse Reporter: Failed to write final merged report to ${finalOutputPath}. Error: ${err.message}`);
-        }
-    }
 }
 exports.PlaywrightPulseReporter = PlaywrightPulseReporter;
 exports.default = PlaywrightPulseReporter;

package/dist/types/index.d.ts

@@ -81,12 +81,55 @@ export interface TrendDataPoint {
     flaky?: number;
 }
 export interface PlaywrightPulseReporterOptions {
+    /**
+     * The name of the output JSON file. Kindly do not change.
+     * @default "playwright-pulse-report.json"
+     */
     outputFile?: string;
+    /**
+     * The directory where the report files will be generated.
+     *
+     * Mostly useful while using sharding
+     *
+     * @default "pulse-report"
+     */
     outputDir?: string;
+    /**
+     * Whether to embed images directly as base64 strings in the report.
+     * @default false
+     */
     base64Images?: boolean;
+    /**
+     * Whether to reset the output directory before each run.
+     *
+     * Mostly useful while running multiple test suites in a single run with `&&` operator.
+     *
+     * example: `npx playwright test test1.spec.ts && npx playwright test test2.spec.ts`
+     *
+     * If `resetOnEachRun` is set to `false`, then the report of `test2.spec.ts` will be merged with `test1.spec.ts` report.
+     *
+     * @default true
+     */
     resetOnEachRun?: boolean;
+    /**
+     * A custom description to embed or display in the report.
+     *
+     * If not added, the component will not appear in the html reports
+     */
     reportDescription?: string;
+    /**
+     * Path to a custom logo image file to use in the report, which will be displayed in the header of the html report's logo and favicon.
+     *
+     * If not added, the default logo will be used.
+     */
     logo?: string;
+    /**
+     * The subdirectory within `outputDir` where individual run reports are stored.
+     * Only used when `resetOnEachRun` is `false`.
+     *
+     * @default "pulse-results"
+     */
+    individualReportsSubDir?: string;
 }
 export interface EnvDetails {
     host: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arghajit/dummy",
   "author": "Arghajit Singha",
-  "version": "0.3.38",
+  "version": "0.3.39",
   "description": "A Playwright reporter and dashboard for visualizing test results.",
   "homepage": "https://arghajit47.github.io/playwright-pulse/",
   "repository": {
@@ -40,8 +40,8 @@
     "generate-report": "scripts/generate-report.mjs",
     "merge-pulse-report": "scripts/merge-pulse-report.js",
     "send-email": "scripts/sendReport.mjs",
-    "generate-trend": "scripts/generate-trend.mjs",
     "generate-email-report": "scripts/generate-email-report.mjs",
+    "generate-trend": "scripts/generate-trend.mjs",
     "pulse-logo": "scripts/terminal-logo.mjs"
   },
   "exports": {

package/scripts/config-reader.mjs

@@ -22,159 +22,131 @@ async function findPlaywrightConfig() {
   return { path: null, exists: false };
 }
 
-async function extractOutputDirFromConfig(configPath) {
+async function extractReporterOptionsFromConfig(configPath) {
   let fileContent = "";
   try {
     fileContent = fs.readFileSync(configPath, "utf-8");
   } catch (e) {
-    // If we can't read the file, we can't parse or import it.
-    return null;
+    return {};
   }
 
+  const options = {};
+
   // 1. Strategy: Text Parsing (Safe & Fast)
-  // We try to read the file as text first. This finds the outputDir without
-  // triggering any Node.js warnings or errors.
   try {
-    // Regex matches: outputDir: "value" or outputDir: 'value'
-    const match = fileContent.match(/outputDir:\s*["']([^"']+)["']/);
-
-    if (match && match[1]) {
-      return path.resolve(process.cwd(), match[1]);
-    }
-  } catch (e) {
-    // Ignore text reading errors
-  }
+    const outputDirMatch = fileContent.match(/outputDir:\s*["']([^"']+)["']/);
+    if (outputDirMatch && outputDirMatch[1]) options.outputDir = outputDirMatch[1];
+
+    const outputFileMatch = fileContent.match(/outputFile:\s*["']([^"']+)["']/);
+    if (outputFileMatch && outputFileMatch[1]) options.outputFile = outputFileMatch[1];
+
+    const resetOnEachRunMatch = fileContent.match(/resetOnEachRun:\s*(true|false)/);
+    if (resetOnEachRunMatch) options.resetOnEachRun = resetOnEachRunMatch[1] === "true";
+
+    const individualReportsSubDirMatch = fileContent.match(/individualReportsSubDir:\s*["']([^"']+)["']/);
+    if (individualReportsSubDirMatch && individualReportsSubDirMatch[1]) options.individualReportsSubDir = individualReportsSubDirMatch[1];
+  } catch (e) { }
+
+  // 2. Safety Check and Dynamic Import
+  if (Object.keys(options).length < 3) {
+    // Check if we can safely import()
+    let canImport = true;
+    if (configPath.endsWith(".js")) {
+      let isModulePackage = false;
+      try {
+        const pkgPath = path.resolve(process.cwd(), "package.json");
+        if (fs.existsSync(pkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+          isModulePackage = pkg.type === "module";
+        }
+      } catch (e) {}
 
-  // 2. Safety Check: Detect ESM in CJS to Prevent Node Warnings
-  // The warning "To load an ES module..." happens when we try to import()
-  // a .js file containing ESM syntax (import/export) in a CJS package.
-  // We explicitly check for this and ABORT the import if found.
-  if (configPath.endsWith(".js")) {
-    let isModulePackage = false;
-    try {
-      const pkgPath = path.resolve(process.cwd(), "package.json");
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        isModulePackage = pkg.type === "module";
-      }
-    } catch (e) {}
-
-    if (!isModulePackage) {
-      // Heuristic: Check for ESM syntax (import/export at start of lines)
-      const hasEsmSyntax =
-        /^\s*import\s+/m.test(fileContent) ||
-        /^\s*export\s+/m.test(fileContent);
-
-      if (hasEsmSyntax) {
-        // We found ESM syntax in a .js file within a CJS project.
-        // Attempting to import this WILL trigger the Node.js warning.
-        // Since regex failed to find outputDir, and we can't import safely, we abort now.
-        return null;
+      if (!isModulePackage) {
+        const hasEsmSyntax = /^\s*import\s+/m.test(fileContent) || /^\s*export\s+/m.test(fileContent);
+        if (hasEsmSyntax) canImport = false;
       }
     }
-  }
-
-  // 3. Strategy: Dynamic Import
-  // If we passed the safety check, we try to import the config.
-  try {
-    let config;
-    const configDir = dirname(configPath);
-    const originalDirname = global.__dirname;
-    const originalFilename = global.__filename;
 
-    try {
-      global.__dirname = configDir;
-      global.__filename = configPath;
+    if (canImport) {
+      try {
+        let config;
+        const configDir = dirname(configPath);
+        const originalDirname = global.__dirname;
+        const originalFilename = global.__filename;
 
-      if (configPath.endsWith(".ts")) {
         try {
-          const { register } = await import("node:module");
-          const { pathToFileURL } = await import("node:url");
-          register("ts-node/esm", pathToFileURL("./"));
-          config = await import(pathToFileURL(configPath).href);
-        } catch (tsError) {
-          const tsNode = await import("ts-node");
-          tsNode.register({
-            transpileOnly: true,
-            compilerOptions: { module: "commonjs" },
-          });
-          config = require(configPath);
-        }
-      } else {
-        // Try dynamic import for JS/MJS
-        config = await import(pathToFileURL(configPath).href);
-      }
-
-      // Handle Default Export
-      if (config && config.default) {
-        config = config.default;
-      }
+          global.__dirname = configDir;
+          global.__filename = configPath;
+
+          if (configPath.endsWith(".ts")) {
+            try {
+              const { register } = await import("node:module");
+              const { pathToFileURL } = await import("node:url");
+              register("ts-node/esm", pathToFileURL("./"));
+              config = await import(pathToFileURL(configPath).href);
+            } catch (tsError) {
+              const tsNode = await import("ts-node");
+              tsNode.register({ transpileOnly: true, compilerOptions: { module: "commonjs" } });
+              config = require(configPath);
+            }
+          } else {
+            config = await import(pathToFileURL(configPath).href);
+          }
 
-      if (config) {
-        // Check for Reporter Config
-        if (config.reporter) {
-          const reporters = Array.isArray(config.reporter)
-            ? config.reporter
-            : [config.reporter];
-
-          for (const reporter of reporters) {
-            const reporterName = Array.isArray(reporter)
-              ? reporter[0]
-              : reporter;
-            const reporterOptions = Array.isArray(reporter)
-              ? reporter[1]
-              : null;
-
-            if (
-              typeof reporterName === "string" &&
-              (reporterName.includes("playwright-pulse-report") ||
-                reporterName.includes("@arghajit/playwright-pulse-report") ||
-                reporterName.includes("@arghajit/dummy"))
-            ) {
-              if (reporterOptions && reporterOptions.outputDir) {
-                return path.resolve(process.cwd(), reporterOptions.outputDir);
+          if (config && config.default) config = config.default;
+
+          if (config) {
+            if (config.reporter) {
+              const reporters = Array.isArray(config.reporter) ? config.reporter : [config.reporter];
+              for (const reporter of reporters) {
+                const reporterName = Array.isArray(reporter) ? reporter[0] : reporter;
+                const reporterOptions = Array.isArray(reporter) ? reporter[1] : null;
+
+                if (typeof reporterName === "string" && 
+                   (reporterName.includes("playwright-pulse-report") || 
+                    reporterName.includes("@arghajit/playwright-pulse-report"))) {
+                  if (reporterOptions) {
+                    if (reporterOptions.outputDir) options.outputDir = reporterOptions.outputDir;
+                    if (reporterOptions.outputFile) options.outputFile = reporterOptions.outputFile;
+                    if (reporterOptions.resetOnEachRun !== undefined) options.resetOnEachRun = reporterOptions.resetOnEachRun;
+                    if (reporterOptions.individualReportsSubDir) options.individualReportsSubDir = reporterOptions.individualReportsSubDir;
+                  }
+                }
               }
             }
+            if (config.outputDir && !options.outputDir) options.outputDir = config.outputDir;
           }
+        } finally {
+          global.__dirname = originalDirname;
+          global.__filename = originalFilename;
         }
-
-        // Check for Global outputDir
-        if (config.outputDir) {
-          return path.resolve(process.cwd(), config.outputDir);
-        }
-      }
-    } finally {
-      // Clean up globals
-      global.__dirname = originalDirname;
-      global.__filename = originalFilename;
+      } catch (error) {}
     }
-  } catch (error) {
-    // SILENT CATCH: Do NOT log anything here.
-    return null;
   }
 
-  return null;
+  return options;
 }
 
-export async function getOutputDir(customOutputDirFromArgs = null) {
-  if (customOutputDirFromArgs) {
-    console.log(`Using custom outputDir from CLI: ${customOutputDirFromArgs}`);
-    return path.resolve(process.cwd(), customOutputDirFromArgs);
-  }
-
+export async function getReporterConfig(customOutputDirFromArgs = null) {
   const { path: configPath, exists } = await findPlaywrightConfig();
-  console.log(
-    `Config file search result: ${exists ? configPath : "not found"}`
-  );
+  let options = {};
 
   if (exists) {
-    const outputDirFromConfig = await extractOutputDirFromConfig(configPath);
-    if (outputDirFromConfig) {
-      console.log(`Using outputDir from config: ${outputDirFromConfig}`);
-      return outputDirFromConfig;
-    }
+    options = await extractReporterOptionsFromConfig(configPath);
   }
 
-  console.log(`Using default outputDir: ${DEFAULT_OUTPUT_DIR}`);
-  return path.resolve(process.cwd(), DEFAULT_OUTPUT_DIR);
+  const outputDir = customOutputDirFromArgs 
+    ? path.resolve(process.cwd(), customOutputDirFromArgs)
+    : path.resolve(process.cwd(), options.outputDir || DEFAULT_OUTPUT_DIR);
+
+  const outputFile = options.outputFile || "playwright-pulse-report.json";
+  const resetOnEachRun = options.resetOnEachRun !== undefined ? options.resetOnEachRun : true;
+  const individualReportsSubDir = options.individualReportsSubDir || "pulse-results";
+
+  return { outputDir, outputFile, resetOnEachRun, individualReportsSubDir };
+}
+
+export async function getOutputDir(customOutputDirFromArgs = null) {
+  const config = await getReporterConfig(customOutputDirFromArgs);
+  return config.outputDir;
 }

package/scripts/generate-email-report.mjs

@@ -4,6 +4,7 @@ import * as fs from "fs/promises";
 import path from "path";
 import { getOutputDir } from "./config-reader.mjs";
 import { animate } from "./terminal-logo.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 // Use dynamic import for chalk as it's ESM only
 let chalk;
@@ -758,6 +759,7 @@ async function main() {
   }
   
   const outputDir = await getOutputDir(customOutputDir);
+  await mergeSequentialReportsIfNeeded(outputDir);
   const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE);
   const minifiedReportHtmlPath = path.resolve(outputDir, MINIFIED_HTML_FILE); // Path for the new minified HTML
 

package/scripts/generate-report.mjs

@@ -7,6 +7,7 @@ import { fork } from "child_process";
 import { fileURLToPath } from "url";
 import { getOutputDir } from "./config-reader.mjs";
 import { animate } from "./terminal-logo.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -5298,6 +5299,7 @@ async function main() {
   );
 
   const outputDir = await getOutputDir(customOutputDir);
+  await mergeSequentialReportsIfNeeded(outputDir);
   const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE); // Current run's main JSON
   const reportHtmlPath = path.resolve(outputDir, DEFAULT_HTML_FILE);
 

package/scripts/generate-static-report.mjs

@@ -7,6 +7,7 @@ import { fork } from "child_process";
 import { fileURLToPath } from "url";
 import { getOutputDir } from "./config-reader.mjs";
 import { animate } from "./terminal-logo.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -6462,11 +6463,13 @@ function generateHTML(reportData, trendData = null) {
     function switchRetryTab(event, tabId) {
         // Find container
         const container = event.target.closest('.retry-tabs-container');
+        if (!container) return;
         
         // Update tab buttons
         const buttons = container.querySelectorAll('.retry-tab');
         buttons.forEach(btn => btn.classList.remove('active'));
-        event.target.classList.add('active');
+        const activeBtn = event.target.closest('.retry-tab') || event.target;
+        activeBtn.classList.add('active');
         
         // Update content
         const contents = container.querySelectorAll('.retry-tab-content');
@@ -6475,10 +6478,12 @@ function generateHTML(reportData, trendData = null) {
             content.classList.remove('active');
         });
         
-        const activeContent = container.querySelector('#' + tabId);
+        const activeContent = document.getElementById(tabId);
         if (activeContent) {
             activeContent.style.display = 'block';
             activeContent.classList.add('active');
+        } else {
+            console.error('Failed to find retry tab content for id:', tabId);
         }
     }
 
@@ -7159,6 +7164,7 @@ async function main() {
   );
 
   const outputDir = await getOutputDir(customOutputDir);
+  await mergeSequentialReportsIfNeeded(outputDir);
   const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE); // Current run's main JSON
   const reportHtmlPath = path.resolve(outputDir, DEFAULT_HTML_FILE);
 

package/scripts/generate-trend.mjs

@@ -2,6 +2,7 @@
 import * as fs from "fs/promises";
 import path from "path";
 import { getOutputDir } from "./config-reader.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 // Use dynamic import for chalk as it's ESM only for prettier console logs
 let chalk;
@@ -34,6 +35,7 @@ for (let i = 0; i < args.length; i++) {
 
 async function archiveCurrentRunData() {
   const outputDir = await getOutputDir(customOutputDir);
+  await mergeSequentialReportsIfNeeded(outputDir);
   const currentRunJsonPath = path.join(outputDir, CURRENT_RUN_JSON_FILE);
   const historyDir = path.join(outputDir, HISTORY_SUBDIR);
 

package/scripts/merge-pulse-report.js

@@ -182,9 +182,11 @@ function cleanupShardDirectories(shardDirs) {
 // Main execution
 (async () => {
   const { animate } = await import("./terminal-logo.mjs");
+  const { mergeSequentialReportsIfNeeded } = await import("./merge-sequential-reports.mjs");
   await animate();
   
   const REPORT_DIR = await getReportDir();
+  await mergeSequentialReportsIfNeeded(REPORT_DIR);
 
   console.log(`\n🔄 Playwright Pulse - Merge Reports (Sharding Mode)\n`);
   console.log(`  Report directory: ${REPORT_DIR}`);

package/scripts/merge-sequential-reports.mjs

@@ -0,0 +1,205 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+import { getReporterConfig } from "./config-reader.mjs";
+
+/**
+ * Reads all `playwright-pulse-report-*.json` files in the `pulse-results` directory
+ * and merges them into a single `playwright-pulse-report.json`.
+ * It resolves duplicate tests using exactly the same logic as the reporter.
+ * 
+ * @param {string} customOutputDir The base report directory override (from CLI).
+ */
+export async function mergeSequentialReportsIfNeeded(customOutputDir) {
+  const config = await getReporterConfig(customOutputDir);
+
+  // This logic should ONLY run if resetOnEachRun is disabled.
+  if (config.resetOnEachRun) {
+    return;
+  }
+
+  const individualReportsSubDir = config.individualReportsSubDir;
+  const baseOutputFile = config.outputFile;
+  const outputDir = config.outputDir;
+
+  const pulseResultsDir = path.join(outputDir, individualReportsSubDir);
+  const finalOutputPath = path.join(outputDir, 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") {
+      // No individual reports directory found, which is completely fine/normal
+      return;
+    }
+    console.error(
+      `Pulse Reporter: Error reading directory ${pulseResultsDir}:`,
+      error,
+    );
+    return;
+  }
+
+  if (reportFiles.length === 0) {
+    // No matching JSON report files found to merge
+    return;
+  }
+
+  console.log(
+    `\n🔄 Merging ${reportFiles.length} sequential test run(s) from '${individualReportsSubDir}'...`,
+  );
+
+  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 (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 same logic as the reporter
+  const finalMergedResults = getFinalizedResults(allResultsFromAllFiles);
+
+  totalDuration = finalMergedResults.reduce(
+    (acc, r) => acc + (r.duration || 0),
+    0,
+  );
+
+  const combinedRun = {
+    id: `run-${Date.now()}-581d5ad8-ce75-4ca5-94a6-ed29c466c815`,
+    timestamp: latestTimestamp.toISOString(),
+    environment: lastRunEnvironment,
+    totalTests: finalMergedResults.length,
+    passed: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "passed",
+    ).length,
+    failed: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "failed",
+    ).length,
+    skipped: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "skipped",
+    ).length,
+    flaky: finalMergedResults.filter(
+      (r) => (r.final_status || r.status) === "flaky",
+    ).length,
+    duration: totalDuration,
+  };
+
+  const finalReport = {
+    run: combinedRun,
+    results: finalMergedResults,
+    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,
+      ),
+    );
+    console.log(
+      `✅ Merged report with ${finalMergedResults.length} total results saved to ${finalOutputPath}`,
+    );
+
+    // Clean up the pulse-results directory after a successful merge
+    try {
+      await fs.rm(pulseResultsDir, { recursive: true, force: true });
+      console.log(
+        `🧹 Cleaned up temporary reports directory at ${pulseResultsDir}`,
+      );
+    } catch (cleanupErr) {
+      console.warn(
+        `Pulse Reporter: Could not clean up individual reports directory. Error: ${cleanupErr.message}`,
+      );
+    }
+  } catch (err) {
+    console.error(
+      `Pulse Reporter: Failed to write final merged report to ${finalOutputPath}. Error: ${err.message}`,
+    );
+  }
+}
+
+function getFinalizedResults(allResults) {
+  const resultsMap = new Map();
+
+  for (const result of allResults) {
+    if (!resultsMap.has(result.id)) {
+      resultsMap.set(result.id, []);
+    }
+    resultsMap.get(result.id).push(result);
+  }
+
+  const finalResults = [];
+
+  for (const [testId, attempts] of resultsMap.entries()) {
+    // Sort by retry count (ASC) then timestamp (DESC) to ensure stable resolution
+    attempts.sort((a, b) => {
+      if (a.retries !== b.retries) return a.retries - b.retries;
+      return new Date(b.startTime).getTime() - new Date(a.startTime).getTime();
+    });
+
+    const firstAttempt = attempts[0];
+    const retryAttempts = attempts.slice(1);
+
+    const hasActualRetries =
+      retryAttempts.length > 0 &&
+      retryAttempts.some(
+        (attempt) =>
+          attempt.status === "failed" ||
+          attempt.status === "flaky" ||
+          firstAttempt.status === "failed" ||
+          firstAttempt.status === "flaky"
+      );
+
+    if (hasActualRetries) {
+      firstAttempt.retryHistory = retryAttempts;
+
+      const lastAttempt = attempts[attempts.length - 1];
+      firstAttempt.final_status = lastAttempt.status;
+
+      if (lastAttempt.outcome === "flaky" || lastAttempt.status === "flaky") {
+        firstAttempt.outcome = "flaky";
+        firstAttempt.status = "flaky";
+      }
+    } else {
+      delete firstAttempt.final_status;
+      delete firstAttempt.retryHistory;
+    }
+
+    finalResults.push(firstAttempt);
+  }
+
+  return finalResults;
+}

package/scripts/sendReport.mjs

@@ -12,6 +12,7 @@ import { animate } from "./terminal-logo.mjs";
 import { fork } from "child_process";
 import "dotenv/config";
 import { getOutputDir } from "./config-reader.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 let chalk;
 let logo =
@@ -460,6 +461,7 @@ const main = async () => {
   }
 
   const reportDir = await getOutputDir(customOutputDir);
+  await mergeSequentialReportsIfNeeded(reportDir);
   console.log(chalk.blue(`Preparing to send email report...`));
   console.log(chalk.blue(`Report directory set to: ${reportDir}`));