@arghajit/dummy 0.3.38 → 0.3.40

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;
@@ -43,9 +44,7 @@ export declare class PlaywrightPulseReporter implements Reporter {
      *
      * Cleaning up at `onBegin` time guarantees each run starts with a fresh slate.
      */
-    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;
@@ -108,13 +109,6 @@ class PlaywrightPulseReporter {
                     await this._cleanupTemporaryFiles();
                 }
             }
-            // When not resetting on each run, clear stale individual run files
-            // from previous sessions. Without this, _mergeAllRunReports() reads
-            // ALL accumulated files and de-duplicates by test.id, which collapses
-            // results from different sessions into fewer entries than expected.
-            if (!this.resetOnEachRun) {
-                await this._cleanupStaleRunReports();
-            }
         })
             .catch((err) => console.error("Pulse Reporter: Error during initialization:", err));
     }
@@ -523,25 +517,6 @@ 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);
-        try {
-            const files = await fs.readdir(pulseResultsDir);
-            const staleFiles = files.filter((f) => f.startsWith("playwright-pulse-report-") && f.endsWith(".json"));
-            if (staleFiles.length > 0) {
-                await Promise.all(staleFiles.map((f) => fs.unlink(path.join(pulseResultsDir, f))));
-                if (this.printsToStdio()) {
-                    console.log(`PlaywrightPulseReporter: Cleaned up ${staleFiles.length} stale run report(s) from ${pulseResultsDir}`);
-                }
-            }
-        }
-        catch (error) {
-            // ENOENT simply means no previous runs exist — that's fine
-            if ((error === null || error === void 0 ? void 0 : error.code) !== "ENOENT") {
-                console.warn("Pulse Reporter: Warning during cleanup of stale run reports:", error.message);
-            }
-        }
-    }
     async _ensureDirExists(dirPath) {
         try {
             await fs.mkdir(dirPath, { recursive: true });
@@ -625,7 +600,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 +608,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.40",
   "description": "A Playwright reporter and dashboard for visualizing test results.",
   "homepage": "https://arghajit47.github.io/playwright-pulse/",
   "repository": {
@@ -38,10 +38,10 @@
     "logo": "node scripts/terminal-logo.mjs",
     "generate-pulse-report": "scripts/generate-static-report.mjs",
     "generate-report": "scripts/generate-report.mjs",
-    "merge-pulse-report": "scripts/merge-pulse-report.js",
+    "merge-pulse-report": "scripts/merge-pulse-report.mjs",
     "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": {
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build:reporter",
     "report:static": "node ./scripts/generate-static-report.mjs",
     "report:generate": "node ./scripts/generate-report.mjs",
-    "report:merge": "node ./scripts/merge-pulse-report.js",
+    "report:merge": "node ./scripts/merge-pulse-report.mjs",
     "report:email": "node ./scripts/sendReport.mjs",
     "report:minify": "node ./scripts/generate-email-report.mjs",
     "generate-trend": "node ./scripts/generate-trend.mjs"

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

@@ -2,8 +2,9 @@
 
 import * as fs from "fs/promises";
 import path from "path";
-import { getOutputDir } from "./config-reader.mjs";
+import { getReporterConfig } 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;
@@ -24,7 +25,6 @@ try {
 }
 
 const DEFAULT_OUTPUT_DIR = "pulse-report";
-const DEFAULT_JSON_FILE = "playwright-pulse-report.json";
 const MINIFIED_HTML_FILE = "pulse-email-summary.html"; // New minified report
 
 const args = process.argv.slice(2);
@@ -757,8 +757,12 @@ async function main() {
     await animate();
   }
   
-  const outputDir = await getOutputDir(customOutputDir);
-  const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE);
+  const config = await getReporterConfig(customOutputDir);
+  const outputDir = config.outputDir;
+  const outputFile = config.outputFile;
+  
+  await mergeSequentialReportsIfNeeded(outputDir);
+  const reportJsonPath = path.resolve(outputDir, outputFile);
   const minifiedReportHtmlPath = path.resolve(outputDir, MINIFIED_HTML_FILE); // Path for the new minified HTML
 
   console.log(chalk.blue(`Generating email report...`));

package/scripts/generate-report.mjs

@@ -5,8 +5,9 @@ import { readFileSync, existsSync as fsExistsSync } from "fs";
 import path from "path";
 import { fork } from "child_process";
 import { fileURLToPath } from "url";
-import { getOutputDir } from "./config-reader.mjs";
+import { getReporterConfig } 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);
@@ -52,7 +53,6 @@ try {
 }
 // Default configuration
 const DEFAULT_OUTPUT_DIR = "pulse-report";
-const DEFAULT_JSON_FILE = "playwright-pulse-report.json";
 const DEFAULT_HTML_FILE = "playwright-pulse-report.html";
 // Helper functions
 export function ansiToHtml(text) {
@@ -5297,8 +5297,12 @@ async function main() {
     "generate-trend.mjs", // Keeping the filename as per your request
   );
 
-  const outputDir = await getOutputDir(customOutputDir);
-  const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE); // Current run's main JSON
+  const config = await getReporterConfig(customOutputDir);
+  const outputDir = config.outputDir;
+  const outputFile = config.outputFile;
+  
+  await mergeSequentialReportsIfNeeded(outputDir);
+  const reportJsonPath = path.resolve(outputDir, outputFile); // Current run's main JSON
   const reportHtmlPath = path.resolve(outputDir, DEFAULT_HTML_FILE);
 
   const historyDir = path.join(outputDir, "history"); // Directory for historical JSON files

package/scripts/generate-static-report.mjs

@@ -5,8 +5,9 @@ import { readFileSync, existsSync as fsExistsSync } from "fs";
 import path from "path";
 import { fork } from "child_process";
 import { fileURLToPath } from "url";
-import { getOutputDir } from "./config-reader.mjs";
+import { getReporterConfig } 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);
@@ -55,18 +56,8 @@ try {
   };
 }
 
-/**
- * @constant {string} DEFAULT_OUTPUT_DIR
- * The default directory where the report will be generated.
- */
 const DEFAULT_OUTPUT_DIR = "pulse-report";
 
-/**
- * @constant {string} DEFAULT_JSON_FILE
- * The default name for the JSON file containing the test data.
- */
-const DEFAULT_JSON_FILE = "playwright-pulse-report.json";
-
 /**
  * @constant {string} DEFAULT_HTML_FILE
  * The default name for the generated HTML report file.
@@ -6462,11 +6453,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 +6468,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);
         }
     }
 
@@ -7158,8 +7153,12 @@ async function main() {
     "generate-trend.mjs", // Keeping the filename as per your request
   );
 
-  const outputDir = await getOutputDir(customOutputDir);
-  const reportJsonPath = path.resolve(outputDir, DEFAULT_JSON_FILE); // Current run's main JSON
+  const config = await getReporterConfig(customOutputDir);
+  const outputDir = config.outputDir;
+  const outputFile = config.outputFile;
+
+  await mergeSequentialReportsIfNeeded(outputDir);
+  const reportJsonPath = path.resolve(outputDir, outputFile); // Current run's main JSON
   const reportHtmlPath = path.resolve(outputDir, DEFAULT_HTML_FILE);
 
   const historyDir = path.join(outputDir, "history"); // Directory for historical JSON files

package/scripts/generate-trend.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import * as fs from "fs/promises";
 import path from "path";
-import { getOutputDir } from "./config-reader.mjs";
+import { getReporterConfig } 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;
@@ -18,7 +19,6 @@ try {
 }
 
 const DEFAULT_OUTPUT_DIR = "pulse-report";
-const CURRENT_RUN_JSON_FILE = "playwright-pulse-report.json"; // Source of the current run data
 const HISTORY_SUBDIR = "history"; // Subdirectory for historical JSON files
 const HISTORY_FILE_PREFIX = "trend-";
 const MAX_HISTORY_FILES = 15; // Store last 15 runs
@@ -33,8 +33,12 @@ for (let i = 0; i < args.length; i++) {
 }
 
 async function archiveCurrentRunData() {
-  const outputDir = await getOutputDir(customOutputDir);
-  const currentRunJsonPath = path.join(outputDir, CURRENT_RUN_JSON_FILE);
+  const config = await getReporterConfig(customOutputDir);
+  const outputDir = config.outputDir;
+  const outputFile = config.outputFile;
+  
+  await mergeSequentialReportsIfNeeded(outputDir);
+  const currentRunJsonPath = path.join(outputDir, outputFile);
   const historyDir = path.join(outputDir, HISTORY_SUBDIR);
 
   try {

package/scripts/{merge-pulse-report.js → merge-pulse-report.mjs}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
+import * as fs from "fs";
+import path from "path";
+import { getReporterConfig } from "./config-reader.mjs";
+import { animate } from "./terminal-logo.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 const args = process.argv.slice(2);
 let customOutputDir = null;
@@ -13,33 +16,23 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
-const OUTPUT_FILE = "playwright-pulse-report.json";
-
 /**
- * Securely resolves the report directory.
- * Prevents Path Traversal by ensuring the output directory
- * is contained within the current working directory.
+ * Securely resolves the report directory and config.
  */
-async function getReportDir() {
+async function getFullConfig() {
+  const config = await getReporterConfig(customOutputDir);
+  
   if (customOutputDir) {
     const resolvedPath = path.resolve(process.cwd(), customOutputDir);
-
     if (!resolvedPath.startsWith(process.cwd())) {
       console.error(
         "⛔ Security Error: Custom output directory must be within the current project root.",
       );
       process.exit(1);
     }
-
-    return resolvedPath;
   }
 
-  try {
-    const { getOutputDir } = await import("./config-reader.mjs");
-    return await getOutputDir();
-  } catch (error) {
-    return path.resolve(process.cwd(), "pulse-report");
-  }
+  return config;
 }
 
 /**
@@ -54,14 +47,14 @@ function getShardDirectories(dir) {
 
   return fs
     .readdirSync(dir, { withFileTypes: true })
-    .filter((dirent) => dirent.isDirectory() && dirent.name !== "attachments")
+    .filter((dirent) => dirent.isDirectory() && dirent.name !== "attachments" && dirent.name !== "pulse-results")
     .map((dirent) => path.join(dir, dirent.name));
 }
 
 /**
  * Merges JSON reports from all shard directories.
  */
-function mergeReports(shardDirs) {
+function mergeReports(shardDirs, outputFile) {
   let combinedRun = {
     totalTests: 0,
     passed: 0,
@@ -76,10 +69,10 @@ function mergeReports(shardDirs) {
   let allEnvironments = [];
 
   for (const shardDir of shardDirs) {
-    const jsonPath = path.join(shardDir, OUTPUT_FILE);
+    const jsonPath = path.join(shardDir, outputFile);
 
     if (!fs.existsSync(jsonPath)) {
-      console.warn(`  Warning: No ${OUTPUT_FILE} found in ${path.basename(shardDir)}`);
+      console.warn(`  Warning: No ${outputFile} found in ${path.basename(shardDir)}`);
       continue;
     }
 
@@ -181,13 +174,17 @@ function cleanupShardDirectories(shardDirs) {
 
 // Main execution
 (async () => {
-  const { animate } = await import("./terminal-logo.mjs");
   await animate();
   
-  const REPORT_DIR = await getReportDir();
+  const config = await getFullConfig();
+  const REPORT_DIR = config.outputDir;
+  const OUTPUT_FILE = config.outputFile;
+
+  await mergeSequentialReportsIfNeeded(REPORT_DIR);
 
   console.log(`\n🔄 Playwright Pulse - Merge Reports (Sharding Mode)\n`);
   console.log(`  Report directory: ${REPORT_DIR}`);
+  console.log(`  Output file: ${OUTPUT_FILE}`);
   if (customOutputDir) {
     console.log(`  (from CLI argument)`);
   } else {
@@ -201,7 +198,7 @@ function cleanupShardDirectories(shardDirs) {
   if (shardDirs.length === 0) {
     console.log("❌ No shard directories found.");
     console.log(
-      "   Expected structure: <report-dir>/<shard-folder>/playwright-pulse-report.json",
+      `   Expected structure: <report-dir>/<shard-folder>/${OUTPUT_FILE}`,
     );
     process.exit(0);
   }
@@ -214,7 +211,7 @@ function cleanupShardDirectories(shardDirs) {
 
   // 2. Merge JSON Reports
   console.log(`🔀 Merging reports...`);
-  const merged = mergeReports(shardDirs);
+  const merged = mergeReports(shardDirs, OUTPUT_FILE);
   console.log(`  ✓ Merged ${shardDirs.length} report(s)`);
   console.log();
 

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

@@ -11,7 +11,8 @@ import { fileURLToPath } from "url";
 import { animate } from "./terminal-logo.mjs";
 import { fork } from "child_process";
 import "dotenv/config";
-import { getOutputDir } from "./config-reader.mjs";
+import { getReporterConfig } from "./config-reader.mjs";
+import { mergeSequentialReportsIfNeeded } from "./merge-sequential-reports.mjs";
 
 let chalk;
 let logo =
@@ -42,8 +43,10 @@ for (let i = 0; i < args.length; i++) {
 let fetch;
 let projectName;
 
-function getUUID(reportDir) {
-  const reportPath = path.join(reportDir, "playwright-pulse-report.json");
+async function getUUID(reportDir) {
+  const config = await getReporterConfig(customOutputDir);
+  const outputFile = config.outputFile;
+  const reportPath = path.join(reportDir, outputFile);
   console.log("Report path:", reportPath);
 
   if (!fsExistsSync(reportPath)) {
@@ -65,8 +68,10 @@ function formatDuration(ms) {
   return `${(ms / 3600000).toFixed(1)}h`;
 }
 
-const getPulseReportSummary = (reportDir) => {
-  const reportPath = path.join(reportDir, "playwright-pulse-report.json");
+const getPulseReportSummary = async (reportDir) => {
+  const config = await getReporterConfig(customOutputDir);
+  const outputFile = config.outputFile;
+  const reportPath = path.join(reportDir, outputFile);
 
   if (!fsExistsSync(reportPath)) {
     throw new Error("Pulse report file not found.");
@@ -286,8 +291,9 @@ const sendEmail = async (credentials, reportDir) => {
 
   try {
     console.log("Starting the sendEmail function...");
-    const reportData = getPulseReportSummary(reportDir);
-    const htmlContent = generateHtmlTable(reportData);
+    const uuid = await getUUID(reportDir);
+    const summary = await getPulseReportSummary(reportDir);
+    const htmlContent = generateHtmlTable(summary);
 
     const recipients = [
       process.env.RECIPIENT_EMAIL_1 || "",
@@ -460,6 +466,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}`));