@arghajit/playwright-pulse-report 0.1.0

package/README.md

@@ -0,0 +1,192 @@
+
+# Playwright Pulse Reporter & Dashboard
+
+This project provides both a custom Playwright reporter and a Next.js web dashboard to visualize your Playwright test results, now with support for **Playwright sharding** and an option for a **standalone HTML report**.
+
+## How it Works
+
+1.  **Reporter (`playwright-pulse-reporter.ts`):**
+    *   A custom reporter that collects detailed results during your Playwright test run.
+    *   **Sharding Support:** If tests are sharded, each shard process writes its results to a temporary file (`.pulse-shard-results-*.json`) in the specified output directory. The main reporter process then merges these files upon completion.
+2.  **JSON Output:** On completion (`onEnd`), the reporter writes all collected (and potentially merged) data into a single `playwright-pulse-report.json` file in your project's specified output directory (defaults to `pulse-report-output` in the project root).
+3.  **Next.js Dashboard (Option 2 - Interactive):** A web application built with Next.js that reads the final `playwright-pulse-report.json` file from the *dashboard project's root* and presents the test results in a dynamic, interactive dashboard interface.
+4.  **Standalone HTML Report (Option 1 - Static):** A script (`generate-static-report.mjs`) that reads the `playwright-pulse-report.json` from the *Playwright project's output directory* (e.g., `pulse-report-output`) and generates a single, self-contained `playwright-pulse-static-report.html` file in the *same directory*. This static report mimics the key information and layout of the dashboard, including:
+    *   Run summary metrics (Total, Passed, Failed, Skipped, Duration).
+    *   Filtering controls for test results.
+    *   List of individual test results with status, duration, name, suite, and errors.
+    *   Expandable details for each test, including steps, error messages, stack traces, attachments (links), and source location.
+
+## Setup
+
+### 1. Install the Reporter Package
+
+In your main Playwright project (the one containing your tests), install this reporter package:
+
+```bash
+npm install @arghajit/playwright-pulse-reporter --save-dev
+# or
+yarn add @arghajit/playwright-pulse-reporter --dev
+# or
+pnpm add @arghajit/playwright-pulse-reporter --save-dev
+```
+
+*(Replace `@arghajit/playwright-pulse-reporter` with the actual published package name if you customized it)*
+
+### 2. Configure Playwright
+
+In your `playwright.config.ts` (or `.js`) file, add the custom reporter to the `reporter` array:
+
+```typescript
+// playwright.config.ts
+import { defineConfig, devices } from '@playwright/test';
+import * as path from 'path';
+
+// Define where the final report JSON and HTML should go
+const PULSE_REPORT_DIR = path.resolve(__dirname, 'pulse-report-output'); // Example: a directory in your project root
+
+export default defineConfig({
+  // ... other configurations like projects, testDir, etc.
+
+  // Define the output directory for Playwright's own artifacts (traces, screenshots)
+  // This is separate from the Pulse reporter's output directory.
+  outputDir: './test-results/',
+
+  reporter: [
+    ['list'], // Keep other reporters like 'list' or 'html' if desired
+
+    // Add the Playwright Pulse Reporter
+    ['@arghajit/playwright-pulse-reporter', {
+        // Optional: Specify the output file name (defaults to 'playwright-pulse-report.json')
+        // outputFile: 'my-custom-report-name.json',
+
+        // REQUIRED: Specify the directory for the final JSON report
+        // The static HTML report will also be generated here.
+        // It's recommended to use an absolute path or one relative to the config file.
+        outputDir: PULSE_REPORT_DIR
+    }]
+  ],
+
+  // Enable sharding if needed
+  // fullyParallel: true, // Often used with sharding
+  // workers: process.env.CI ? 4 : undefined, // Example worker count
+
+  // ... other configurations
+});
+```
+
+**Explanation:**
+
+*   `outputDir` in the main `defineConfig`: This is where Playwright stores its own artifacts like traces and screenshots.
+*   `outputDir` inside the `@arghajit/playwright-pulse-reporter` options: This tells *our reporter* where to save the final `playwright-pulse-report.json`. Using a dedicated directory like `pulse-report-output` is **required** for the reporter and static report generation to work correctly.
+
+### 3. Run Your Tests
+
+Execute your Playwright tests as usual. This command works whether you use sharding or not:
+
+```bash
+npx playwright test
+# or specific configurations like:
+# npx playwright test --project=chromium --shard=1/3
+```
+
+The `@arghajit/playwright-pulse-reporter` will automatically handle sharding if Playwright is configured to use it. Upon completion, the final `playwright-pulse-report.json` will be generated in the directory you specified (e.g., `pulse-report-output`).
+
+### 4. Generate the Static HTML Report (Option 1)
+
+After your tests run and `playwright-pulse-report.json` is created, you can generate the standalone HTML report using the command provided by the package:
+
+1.  **Navigate to your Playwright project directory** (the one where you ran the tests).
+2.  **Run the generation command:**
+    ```bash
+    npx generate-pulse-report
+    ```
+    This command executes the `scripts/generate-static-report.mjs` script included in the `@arghajit/playwright-pulse-reporter` package. It reads the `pulse-report-output/playwright-pulse-report.json` file (relative to your current directory) and creates `pulse-report-output/playwright-pulse-static-report.html`.
+3.  **Open the HTML file:** Open the generated `pulse-report-output/playwright-pulse-static-report.html` in your browser.
+
+This HTML file is self-contained and provides a detailed, interactive dashboard-like overview suitable for sharing or archiving.
+
+### 5. View the Next.js Dashboard (Option 2 - *Currently Part of the Same Project*)
+
+**Note:** The Next.js dashboard is currently part of the reporter project itself. To view it:
+
+1.  **Navigate to the Reporter/Dashboard Project:**
+    ```bash
+    cd path/to/playwright-pulse-reporter # The directory containing THIS dashboard code
+    ```
+2.  **Install Dependencies:**
+    ```bash
+    npm install
+    # or yarn install or pnpm install
+    ```
+3.  **Copy the Report File:** Copy the `playwright-pulse-report.json` file generated by your tests (e.g., from your main project's `pulse-report-output` directory) into the **root directory** of *this dashboard project*.
+    ```bash
+    # Example: Copying from your main project to the dashboard project directory
+    cp ../my-playwright-project/pulse-report-output/playwright-pulse-report.json ./
+    ```
+    **Tip for Development:** You can also use the `sample-report.json` file included in this project for development:
+    ```bash
+    cp sample-report.json ./playwright-pulse-report.json
+    ```
+4.  **Start the Dashboard:**
+    ```bash
+    npm run dev
+    # or yarn dev or pnpm dev
+    ```
+
+This will start the Next.js dashboard (usually on `http://localhost:9002`).
+
+**Alternatively, build and start for production:**
+
+```bash
+# Ensure the report JSON is in the root first
+npm run build
+npm run start
+```
+
+## Development (Contributing to this Project)
+
+To work on the reporter or the dashboard itself:
+
+1.  **Clone the repository:**
+    ```bash
+    git clone <repository-url>
+    cd playwright-pulse-reporter
+    ```
+2.  **Install dependencies:**
+    ```bash
+    npm install
+    ```
+3.  **Build the reporter:** (Needed if you make changes to the reporter code)
+    ```bash
+    npm run build:reporter
+    ```
+4.  **Run the dashboard in development mode:**
+    ```bash
+    # Make sure a playwright-pulse-report.json exists in the root
+    # Using the sample data:
+    cp sample-report.json ./playwright-pulse-report.json
+    npm run dev
+    ```
+5.  **Test static report generation:**
+    ```bash
+    # 1. Ensure playwright-pulse-report.json exists in pulse-report-output
+    mkdir -p pulse-report-output
+    cp sample-report.json pulse-report-output/playwright-pulse-report.json
+    # 2. Run the generation script directly using node (or via the bin command)
+    node ./scripts/generate-static-report.mjs
+    # or
+    # npx generate-pulse-report
+    ```
+
+## Key Files
+
+*   `src/reporter/index.ts`: The entry point for the Playwright reporter logic (exports the class).
+*   `src/reporter/playwright-pulse-reporter.ts`: The core Playwright reporter implementation (handles sharding, generates JSON).
+*   `scripts/generate-static-report.mjs`: Script to generate the standalone HTML report (executed via `npx generate-pulse-report`).
+*   `src/lib/data-reader.ts`: Server-side logic for reading the JSON report file (used by Next.js dashboard).
+*   `src/lib/data.ts`: Data fetching functions used by the Next.js dashboard components.
+*   `src/app/`: Contains the Next.js dashboard pages and components.
+*   `pulse-report-output/playwright-pulse-report.json`: (Generated by the reporter in the *user's project*) The primary data source.
+*   `pulse-report-output/playwright-pulse-static-report.html`: (Generated by the script in the *user's project*) The standalone HTML report.
+*   `playwright-pulse-report.json`: (Manually copied to the *dashboard project root*) Used by the Next.js dashboard.
+*   `sample-report.json`: (Included in this project) Dummy data for development/testing visualization.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { PlaywrightPulseReporter } from "./playwright-pulse-reporter";
+export default PlaywrightPulseReporter;
+export { PlaywrightPulseReporter };
+export * from "../types";
+export * from "../lib/report-types";

package/dist/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightPulseReporter = void 0;
+// src/reporter/index.ts
+const playwright_pulse_reporter_1 = require("./playwright-pulse-reporter");
+Object.defineProperty(exports, "PlaywrightPulseReporter", { enumerable: true, get: function () { return playwright_pulse_reporter_1.PlaywrightPulseReporter; } });
+// Export the reporter class as the default export for CommonJS compatibility
+// and also as a named export for potential ES module consumers.
+exports.default = playwright_pulse_reporter_1.PlaywrightPulseReporter;
+// You can also export other related types or utilities if needed
+__exportStar(require("../types"), exports); // Re-export shared types if they are used by the reporter consumers
+__exportStar(require("../lib/report-types"), exports);

package/dist/lib/report-types.d.ts

@@ -0,0 +1,8 @@
+import type { TestResult, TestRun } from '@/types';
+export interface PlaywrightPulseReport {
+    run: TestRun | null;
+    results: TestResult[];
+    metadata: {
+        generatedAt: string;
+    };
+}

package/dist/lib/report-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,26 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult as PwTestResult } from "@playwright/test/reporter";
+export declare class PlaywrightPulseReporter implements Reporter {
+    private config;
+    private suite;
+    private results;
+    private runStartTime;
+    private outputDir;
+    private baseOutputFile;
+    private isSharded;
+    private shardIndex;
+    constructor(options?: {
+        outputFile?: string;
+        outputDir?: string;
+    });
+    printsToStdio(): boolean;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onTestBegin(test: TestCase): void;
+    private processStep;
+    onTestEnd(test: TestCase, result: PwTestResult): void;
+    onError(error: any): void;
+    private _writeShardResults;
+    private _mergeShardResults;
+    private _cleanupTemporaryFiles;
+    private _ensureDirExists;
+    onEnd(result: FullResult): Promise<void>;
+}

package/dist/playwright-pulse-reporter.js

@@ -0,0 +1,304 @@
+"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 = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+// Helper to convert Playwright status to Pulse status
+const convertStatus = (status) => {
+    if (status === "passed")
+        return "passed";
+    if (status === "failed" || status === "timedOut" || status === "interrupted")
+        return "failed";
+    return "skipped";
+};
+const TEMP_SHARD_FILE_PREFIX = ".pulse-shard-results-";
+// Use standard ES module export
+class PlaywrightPulseReporter {
+    constructor(options = {}) {
+        var _a;
+        this.results = []; // Holds results *per process* (main or shard)
+        this.baseOutputFile = "playwright-pulse-report.json";
+        this.isSharded = false;
+        this.shardIndex = undefined;
+        this.baseOutputFile = (_a = options.outputFile) !== null && _a !== void 0 ? _a : this.baseOutputFile;
+        // Initial outputDir setup (will be refined in onBegin)
+        const baseDir = options.outputDir
+            ? path.resolve(options.outputDir)
+            : process.cwd();
+        this.outputDir = baseDir;
+        console.log(`PlaywrightPulseReporter: Initial Output dir configured to ${this.outputDir}`);
+    }
+    printsToStdio() {
+        return this.shardIndex === undefined || this.shardIndex === 0;
+    }
+    onBegin(config, suite) {
+        this.config = config;
+        this.suite = suite;
+        this.runStartTime = Date.now();
+        const totalShards = parseInt(process.env.PLAYWRIGHT_SHARD_TOTAL || "1", 10);
+        this.isSharded = totalShards > 1;
+        if (process.env.PLAYWRIGHT_SHARD_INDEX !== undefined) {
+            this.shardIndex = parseInt(process.env.PLAYWRIGHT_SHARD_INDEX, 10);
+        }
+        const configDir = this.config.rootDir;
+        this.outputDir = this.outputDir
+            ? path.resolve(configDir, this.outputDir)
+            : path.resolve(configDir, "pulse-report-output");
+        console.log(`PlaywrightPulseReporter: Final Output dir resolved to ${this.outputDir}`);
+        if (this.shardIndex === undefined) {
+            // Main process
+            console.log(`PlaywrightPulseReporter: Starting test run with ${suite.allTests().length} tests${this.isSharded ? ` across ${totalShards} shards` : ""}. Outputting to ${this.outputDir}`);
+            this._cleanupTemporaryFiles().catch((err) => console.error("Pulse Reporter: Error cleaning up temp files:", err));
+        }
+        else {
+            // Shard process
+            console.log(`PlaywrightPulseReporter: Shard ${this.shardIndex + 1}/${totalShards} starting. Outputting temp results to ${this.outputDir}`);
+        }
+    }
+    onTestBegin(test) {
+        // Optional: Log test start
+    }
+    processStep(step, parentStatus) {
+        var _a;
+        const inherentStatus = parentStatus === "failed" || parentStatus === "skipped"
+            ? parentStatus
+            : convertStatus(step.error ? "failed" : "passed");
+        const duration = step.duration;
+        const startTime = new Date(step.startTime);
+        const endTime = new Date(startTime.getTime() + Math.max(0, duration));
+        return {
+            id: `${step.title}-${startTime.toISOString()}-${duration}-${Math.random()
+                .toString(16)
+                .slice(2)}`,
+            title: step.title,
+            status: inherentStatus,
+            duration: duration,
+            startTime: startTime,
+            endTime: endTime,
+            errorMessage: (_a = step.error) === null || _a === void 0 ? void 0 : _a.message,
+            screenshot: undefined, // Placeholder
+        };
+    }
+    onTestEnd(test, result) {
+        var _a, _b, _c, _d, _e;
+        const testStatus = convertStatus(result.status);
+        const startTime = new Date(result.startTime);
+        const endTime = new Date(startTime.getTime() + result.duration);
+        const processAllSteps = (steps, parentTestStatus) => {
+            let processed = [];
+            for (const step of steps) {
+                const processedStep = this.processStep(step, parentTestStatus);
+                processed.push(processedStep);
+                if (step.steps.length > 0) {
+                    processed = processed.concat(processAllSteps(step.steps, processedStep.status));
+                }
+            }
+            return processed;
+        };
+        let codeSnippet = undefined;
+        try {
+            if ((_a = test.location) === null || _a === void 0 ? void 0 : _a.file) {
+                codeSnippet = `Test defined at: ${test.location.file}:${test.location.line}:${test.location.column}`;
+            }
+        }
+        catch (e) {
+            console.warn(`Pulse Reporter: Could not extract code snippet for ${test.title}`, e);
+        }
+        const pulseResult = {
+            id: test.id ||
+                `${test.title}-${startTime.toISOString()}-${Math.random()
+                    .toString(16)
+                    .slice(2)}`,
+            runId: "TBD",
+            name: test.titlePath().join(" > "),
+            suiteName: test.parent.title,
+            status: testStatus,
+            duration: result.duration,
+            startTime: startTime,
+            endTime: endTime,
+            retries: result.retry,
+            steps: processAllSteps(result.steps, testStatus),
+            errorMessage: (_b = result.error) === null || _b === void 0 ? void 0 : _b.message,
+            stackTrace: (_c = result.error) === null || _c === void 0 ? void 0 : _c.stack,
+            codeSnippet: codeSnippet,
+            screenshot: (_d = result.attachments.find((a) => a.name === "screenshot")) === null || _d === void 0 ? void 0 : _d.path,
+            video: (_e = result.attachments.find((a) => a.name === "video")) === null || _e === void 0 ? void 0 : _e.path,
+            tags: test.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
+        };
+        this.results.push(pulseResult);
+    }
+    onError(error) {
+        var _a;
+        console.error(`PlaywrightPulseReporter: Error encountered (Shard: ${(_a = this.shardIndex) !== null && _a !== void 0 ? _a : "Main"}):`, error);
+    }
+    async _writeShardResults() {
+        if (this.shardIndex === undefined) {
+            console.warn("Pulse Reporter: _writeShardResults called in main process. Skipping.");
+            return;
+        }
+        const tempFilePath = path.join(this.outputDir, `${TEMP_SHARD_FILE_PREFIX}${this.shardIndex}.json`);
+        try {
+            await this._ensureDirExists(this.outputDir);
+            await fs.writeFile(tempFilePath, JSON.stringify(this.results, null, 2));
+        }
+        catch (error) {
+            console.error(`Pulse Reporter: Shard ${this.shardIndex} failed to write temporary results to ${tempFilePath}`, error);
+        }
+    }
+    async _mergeShardResults(finalRunData) {
+        console.log("Pulse Reporter: Merging results from shards...");
+        let allResults = [];
+        const totalShards = parseInt(process.env.PLAYWRIGHT_SHARD_TOTAL || "1", 10);
+        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);
+                shardResults.forEach((r) => (r.runId = finalRunData.id));
+                allResults = allResults.concat(shardResults);
+            }
+            catch (error) {
+                if (error && error.code === "ENOENT") {
+                    console.warn(`Pulse Reporter: Shard results file not found: ${tempFilePath}.`);
+                }
+                else {
+                    console.warn(`Pulse Reporter: Could not read or parse results from shard ${i} (${tempFilePath}). Error: ${error}`);
+                }
+            }
+        }
+        console.log(`Pulse Reporter: Merged a total of ${allResults.length} results from ${totalShards} shards.`);
+        finalRunData.passed = allResults.filter((r) => r.status === "passed").length;
+        finalRunData.failed = allResults.filter((r) => r.status === "failed").length;
+        finalRunData.skipped = allResults.filter((r) => r.status === "skipped").length;
+        finalRunData.totalTests = allResults.length;
+        return {
+            run: finalRunData,
+            results: allResults,
+            metadata: { generatedAt: new Date().toISOString() },
+        };
+    }
+    async _cleanupTemporaryFiles() {
+        try {
+            await this._ensureDirExists(this.outputDir);
+            const files = await fs.readdir(this.outputDir);
+            const tempFiles = files.filter((f) => f.startsWith(TEMP_SHARD_FILE_PREFIX));
+            if (tempFiles.length > 0) {
+                console.log(`Pulse Reporter: Cleaning up ${tempFiles.length} temporary shard files...`);
+                await Promise.all(tempFiles.map((f) => fs.unlink(path.join(this.outputDir, f))));
+            }
+        }
+        catch (error) {
+            if (error && error.code !== "ENOENT") {
+                console.error("Pulse Reporter: Error cleaning up temporary files:", error);
+            }
+        }
+    }
+    async _ensureDirExists(dirPath) {
+        try {
+            await fs.mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            if (error && error.code !== "EEXIST") {
+                console.error(`Pulse Reporter: Failed to ensure directory exists: ${dirPath}`, error);
+                throw error;
+            }
+        }
+    }
+    async onEnd(result) {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.shardIndex !== undefined) {
+            await this._writeShardResults();
+            console.log(`PlaywrightPulseReporter: Shard ${this.shardIndex + 1} finished.`);
+            return;
+        }
+        const runEndTime = Date.now();
+        const duration = runEndTime - this.runStartTime;
+        const runId = `run-${this.runStartTime}-${Math.random()
+            .toString(16)
+            .slice(2)}`;
+        const runData = {
+            id: runId,
+            timestamp: new Date(this.runStartTime),
+            totalTests: 0,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration,
+        };
+        let finalReport;
+        if (this.isSharded) {
+            finalReport = await this._mergeShardResults(runData);
+        }
+        else {
+            this.results.forEach((r) => (r.runId = runId));
+            runData.passed = this.results.filter((r) => r.status === "passed").length;
+            runData.failed = this.results.filter((r) => r.status === "failed").length;
+            runData.skipped = this.results.filter((r) => r.status === "skipped").length;
+            runData.totalTests = this.results.length;
+            finalReport = {
+                run: runData,
+                results: this.results,
+                metadata: { generatedAt: new Date().toISOString() },
+            };
+        }
+        const finalRunStatus = ((_b = (_a = finalReport.run) === null || _a === void 0 ? void 0 : _a.failed) !== null && _b !== void 0 ? _b : 0 > 0) ? "failed" : "passed";
+        console.log(`PlaywrightPulseReporter: Test run finished with overall status: ${finalRunStatus}`);
+        console.log(`  Passed: ${(_c = finalReport.run) === null || _c === void 0 ? void 0 : _c.passed}, Failed: ${(_d = finalReport.run) === null || _d === void 0 ? void 0 : _d.failed}, Skipped: ${(_e = finalReport.run) === null || _e === void 0 ? void 0 : _e.skipped}`);
+        console.log(`  Total tests: ${(_f = finalReport.run) === null || _f === void 0 ? void 0 : _f.totalTests}`);
+        console.log(`  Total time: ${(duration / 1000).toFixed(2)}s`);
+        const finalOutputPath = path.join(this.outputDir, this.baseOutputFile);
+        try {
+            await this._ensureDirExists(this.outputDir);
+            await fs.writeFile(finalOutputPath, JSON.stringify(finalReport, (key, value) => {
+                if (value instanceof Date) {
+                    return value.toISOString();
+                }
+                return value;
+            }, 2));
+            console.log(`PlaywrightPulseReporter: Final report written to ${finalOutputPath}`);
+        }
+        catch (error) {
+            console.error(`PlaywrightPulseReporter: Failed to write final report to ${finalOutputPath}`, error);
+        }
+        finally {
+            if (this.isSharded) {
+                await this._cleanupTemporaryFiles();
+            }
+        }
+    }
+}
+exports.PlaywrightPulseReporter = PlaywrightPulseReporter;
+// No module.exports needed for ES modules

package/dist/reporter/attachment-utils.d.ts

@@ -0,0 +1,10 @@
+import type { TestResult as PwTestResult } from "@playwright/test/reporter";
+import type { TestResult, PlaywrightPulseReporterOptions } from "../types";
+/**
+ * Processes attachments from a Playwright TestResult and updates the PulseTestResult.
+ * @param testId A unique identifier for the test, used for folder naming.
+ * @param pwResult The TestResult object from Playwright.
+ * @param pulseResult The internal test result structure to update.
+ * @param config The reporter configuration options.
+ */
+export declare function attachFiles(testId: string, pwResult: PwTestResult, pulseResult: TestResult, config: PlaywrightPulseReporterOptions): void;