@testdino/playwright 1.0.7 → 1.0.8

package/dist/index.mjs

@@ -1,12 +1,18 @@
-import { randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
 import { existsSync, readFileSync, statSync, createReadStream } from 'fs';
 import WebSocket from 'ws';
 import axios from 'axios';
-import { readFile } from 'fs/promises';
+import { basename, extname, relative } from 'path';
+import { rm, mkdir, readFile } from 'fs/promises';
 import { execa } from 'execa';
 import { type, release, platform, cpus, totalmem, hostname } from 'os';
 import { version } from 'process';
-import { basename, extname } from 'path';
+import istanbulCoverage from 'istanbul-lib-coverage';
+import { createContext } from 'istanbul-lib-report';
+import { create } from 'istanbul-reports';
+import { test as test$1 } from '@playwright/test';
+export { expect } from '@playwright/test';
+import chalk from 'chalk';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -366,8 +372,12 @@ var WebSocketClient = class {
     }
   }
 };
-
-// src/utils/index.ts
+function normalizePath(filePath, rootDir) {
+  if (rootDir && filePath.startsWith(rootDir)) {
+    return relative(rootDir, filePath);
+  }
+  return filePath;
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1514,7 +1524,7 @@ var PlaywrightMetadataCollector = class extends BaseMetadataCollector {
       const skeletonSuite = {
         title: childSuite.title,
         type: childSuite.type === "file" ? "file" : "describe",
-        tests: childSuite.tests.map((test) => this.buildSkeletonTest(test))
+        tests: childSuite.tests.map((test2) => this.buildSkeletonTest(test2))
       };
       if (childSuite.type === "file" && childSuite.location) {
         skeletonSuite.file = childSuite.location.file;
@@ -1536,24 +1546,24 @@ var PlaywrightMetadataCollector = class extends BaseMetadataCollector {
   /**
    * Build skeleton test from TestCase
    */
-  buildSkeletonTest(test) {
+  buildSkeletonTest(test2) {
     const skeletonTest = {
-      testId: test.id,
-      title: test.title,
+      testId: test2.id,
+      title: test2.title,
       location: {
-        file: test.location.file,
-        line: test.location.line,
-        column: test.location.column
+        file: test2.location.file,
+        line: test2.location.line,
+        column: test2.location.column
       }
     };
-    if (test.tags && test.tags.length > 0) {
-      skeletonTest.tags = test.tags;
+    if (test2.tags && test2.tags.length > 0) {
+      skeletonTest.tags = test2.tags;
     }
-    if (test.expectedStatus) {
-      skeletonTest.expectedStatus = test.expectedStatus;
+    if (test2.expectedStatus) {
+      skeletonTest.expectedStatus = test2.expectedStatus;
     }
-    if (test.annotations && test.annotations.length > 0) {
-      skeletonTest.annotations = test.annotations.map((ann) => ({
+    if (test2.annotations && test2.annotations.length > 0) {
+      skeletonTest.annotations = test2.annotations.map((ann) => ({
         type: ann.type,
         description: ann.description
       }));
@@ -1924,8 +1934,324 @@ var ArtifactUploader = class {
     return this.sasToken.uniqueId;
   }
 };
-
-// src/reporter/log.ts
+function toIstanbulMapData(map) {
+  return map;
+}
+function fromIstanbulMapData(data) {
+  return data;
+}
+var CoverageMerger = class {
+  coverageMap = istanbulCoverage.createCoverageMap({});
+  hasData = false;
+  includePatterns;
+  excludePatterns;
+  onError;
+  constructor(options) {
+    this.includePatterns = options?.include;
+    this.excludePatterns = options?.exclude;
+    this.onError = options?.onError;
+  }
+  /**
+   * Merge a coverage fragment from a completed test.
+   * The fragment is merged directly and can be GC'd immediately.
+   */
+  addFragment(fragment) {
+    if (!fragment.istanbul) return;
+    try {
+      const filtered = this.filterCoverageMap(fragment.istanbul);
+      this.coverageMap.merge(toIstanbulMapData(filtered));
+      if (this.coverageMap.files().length > 0) {
+        this.hasData = true;
+      }
+    } catch (error) {
+      const msg = `[TestDino] Failed to merge coverage fragment: ${error instanceof Error ? error.message : String(error)}`;
+      if (this.onError) {
+        this.onError(msg);
+      } else {
+        console.warn(msg);
+      }
+    }
+  }
+  /**
+   * Filter files from a coverage map based on include/exclude patterns.
+   */
+  filterCoverageMap(coverageMap) {
+    const hasInclude = this.includePatterns && this.includePatterns.length > 0;
+    const hasExclude = this.excludePatterns && this.excludePatterns.length > 0;
+    if (!hasInclude && !hasExclude) return coverageMap;
+    const filtered = {};
+    for (const [filePath, fileCoverage] of Object.entries(coverageMap)) {
+      if (hasExclude && this.excludePatterns.some((pattern) => filePath.includes(pattern))) {
+        continue;
+      }
+      if (hasInclude && !this.includePatterns.some((pattern) => filePath.includes(pattern))) {
+        continue;
+      }
+      filtered[filePath] = fileCoverage;
+    }
+    return filtered;
+  }
+  /**
+   * Whether any coverage data has been collected.
+   */
+  get hasCoverage() {
+    return this.hasData;
+  }
+  /**
+   * Compute aggregate summary metrics from the merged coverage map.
+   */
+  computeSummary() {
+    const globalSummary = this.coverageMap.getCoverageSummary();
+    return {
+      lines: extractMetric(globalSummary.lines),
+      branches: extractMetric(globalSummary.branches),
+      functions: extractMetric(globalSummary.functions),
+      statements: extractMetric(globalSummary.statements)
+    };
+  }
+  /**
+   * Compute per-file coverage metrics.
+   * Normalizes file paths to be relative to git root.
+   */
+  computeFileCoverage(gitRoot) {
+    const root = gitRoot || process.cwd();
+    return this.coverageMap.files().map((filePath) => {
+      const fileCoverage = this.coverageMap.fileCoverageFor(filePath);
+      const fileSummary = fileCoverage.toSummary();
+      const normalizedPath = normalizePath(filePath, root);
+      return {
+        path: normalizedPath,
+        lines: extractMetric(fileSummary.lines),
+        branches: extractMetric(fileSummary.branches),
+        functions: extractMetric(fileSummary.functions),
+        statements: extractMetric(fileSummary.statements)
+      };
+    });
+  }
+  /**
+   * Get the raw merged coverage map (for local report generation or compact extraction).
+   */
+  getRawCoverageMap() {
+    return this.coverageMap;
+  }
+  /**
+   * Get the merged coverage map as a plain JSON object.
+   */
+  toJSON() {
+    return fromIstanbulMapData(this.coverageMap.toJSON());
+  }
+};
+function extractMetric(metric) {
+  return {
+    total: metric.total,
+    covered: metric.covered,
+    pct: metric.pct
+  };
+}
+function extractCompactCounts(coverageMapJSON, gitRoot) {
+  const files = {};
+  let fileCount = 0;
+  for (const [filePath, fileCoverage] of Object.entries(coverageMapJSON)) {
+    const normalizedPath = normalizePath(filePath, gitRoot);
+    files[normalizedPath] = {
+      s: fileCoverage.s,
+      f: fileCoverage.f,
+      b: fileCoverage.b,
+      totals: {
+        s: Object.keys(fileCoverage.statementMap || {}).length,
+        f: Object.keys(fileCoverage.fnMap || {}).length,
+        b: countBranchPaths(fileCoverage.branchMap || {})
+      },
+      shapeHash: computeShapeHash(fileCoverage)
+    };
+    fileCount++;
+  }
+  return { files, fileCount };
+}
+function countBranchPaths(branchMap) {
+  let total = 0;
+  for (const branch of Object.values(branchMap)) {
+    total += (branch.locations || []).length;
+  }
+  return total;
+}
+function computeShapeHash(fileCoverage) {
+  const branchMap = fileCoverage.branchMap || {};
+  const shape = {
+    s: Object.keys(fileCoverage.statementMap || {}).length,
+    f: Object.keys(fileCoverage.fnMap || {}).length,
+    b: countBranchPaths(branchMap),
+    bp: Object.values(branchMap).map((b) => (b.locations || []).length)
+  };
+  return createHash("sha256").update(JSON.stringify(shape)).digest("hex").slice(0, 12);
+}
+async function generateIstanbulHtmlReport(coverageMerger, options) {
+  await rm(options.outputDir, { recursive: true, force: true }).catch(() => {
+  });
+  await mkdir(options.outputDir, { recursive: true });
+  const coverageMap = coverageMerger.getRawCoverageMap();
+  const context = createContext({
+    dir: options.outputDir,
+    watermarks: {
+      statements: [50, 80],
+      functions: [50, 80],
+      branches: [50, 80],
+      lines: [50, 80]
+    },
+    coverageMap
+  });
+  const reporter = create("html", {
+    skipEmpty: false,
+    subdir: ""
+  });
+  reporter.execute(context);
+  return `${options.outputDir}/index.html`;
+}
+var COVERAGE_EXTRACT_TIMEOUT_MS = 3e4;
+async function extractCoverageFromPage(page, timeoutMs = COVERAGE_EXTRACT_TIMEOUT_MS) {
+  return Promise.race([
+    page.evaluate(() => globalThis.__coverage__ ?? null),
+    new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+  ]).catch(() => null);
+}
+async function attachCoverageToTestInfo(testInfo, coverage) {
+  const fragment = {
+    istanbul: coverage
+  };
+  await testInfo.attach("testdino-coverage", {
+    body: JSON.stringify(fragment),
+    contentType: "application/json"
+  });
+}
+var coverageFixtures = {
+  _testdinoCoverage: [
+    async ({ page }, use, testInfo) => {
+      await use();
+      const istanbulCoverage2 = await extractCoverageFromPage(page);
+      if (istanbulCoverage2) {
+        await attachCoverageToTestInfo(testInfo, istanbulCoverage2);
+      }
+    },
+    { auto: true }
+  ]
+};
+var test = test$1.extend(
+  coverageFixtures
+);
+function stripAnsi(str) {
+  return str.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function pad(str, len) {
+  const vLen = stripAnsi(str).length;
+  return vLen >= len ? str : str + " ".repeat(len - vLen);
+}
+function padStart(str, len) {
+  const vLen = stripAnsi(str).length;
+  return vLen >= len ? str : " ".repeat(len - vLen) + str;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = (seconds % 60).toFixed(0);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function shortenPath(filePath) {
+  const markers = ["/src/", "/lib/", "/app/"];
+  for (const marker of markers) {
+    const idx = filePath.indexOf(marker);
+    if (idx !== -1) return filePath.slice(idx + 1);
+  }
+  const parts = filePath.split("/");
+  return parts.length > 2 ? parts.slice(-2).join("/") : filePath;
+}
+function colorPct(pct) {
+  const color = pct >= 80 ? chalk.green : pct >= 50 ? chalk.yellow : chalk.red;
+  return color(pct === 100 ? "100%" : `${pct.toFixed(1)}%`);
+}
+function printCoverageTable(event) {
+  const { summary, files } = event;
+  const row = (content) => `  ${chalk.dim("\u2502")} ${content}`;
+  const nameW = 30;
+  const colW = 10;
+  console.log(row(`${chalk.bold("Coverage")}  ${chalk.dim(`${files.length} files`)}`));
+  console.log(row(""));
+  console.log(
+    row(
+      `  ${chalk.dim(`${pad("File", nameW)}${padStart("Stmts", colW)}${padStart("Branch", colW)}${padStart("Funcs", colW)}${padStart("Lines", colW)}`)}`
+    )
+  );
+  for (const file of files) {
+    const name = shortenPath(file.path);
+    const short = name.length > nameW ? name.slice(0, nameW - 1) + "~" : name;
+    console.log(
+      row(
+        `  ${pad(short, nameW)}` + padStart(colorPct(file.statements.pct), colW) + padStart(colorPct(file.branches.pct), colW) + padStart(colorPct(file.functions.pct), colW) + padStart(colorPct(file.lines.pct), colW)
+      )
+    );
+  }
+  console.log(row(`  ${chalk.dim("\u2500".repeat(nameW + colW * 4))}`));
+  console.log(
+    row(
+      `  ${chalk.bold(pad("All files", nameW))}` + padStart(colorPct(summary.statements.pct), colW) + padStart(colorPct(summary.branches.pct), colW) + padStart(colorPct(summary.functions.pct), colW) + padStart(colorPct(summary.lines.pct), colW)
+    )
+  );
+}
+function printRunSummary(result, streamingSuccess, data) {
+  const W = 72;
+  const topBorder = `  ${chalk.dim(`\u250C${"\u2500".repeat(W)}\u2510`)}`;
+  const bottomBorder = `  ${chalk.dim(`\u2514${"\u2500".repeat(W)}\u2518`)}`;
+  const divider = `  ${chalk.dim(`\u251C${"\u2500".repeat(W)}\u2524`)}`;
+  const row = (content) => `  ${chalk.dim("\u2502")} ${content}`;
+  console.log("");
+  console.log(topBorder);
+  console.log(row(chalk.bold("TestDino Run Summary")));
+  console.log(divider);
+  console.log(row(`${chalk.dim("Run")}   ${data.runId}`));
+  const git = data.runMetadata?.git;
+  if (git?.branch || git?.commit?.hash) {
+    const branch = git.branch ? chalk.cyan(git.branch) : "";
+    const sha = git.commit?.hash ? chalk.dim(git.commit.hash.slice(0, 7)) : "";
+    const sep = branch && sha ? `  ${chalk.dim("@")}  ` : "";
+    const msg = git.commit?.message ? `  ${chalk.dim(git.commit.message.split("\n")[0].slice(0, 50))}` : "";
+    console.log(row(`${chalk.dim("Git")}   ${branch}${sep}${sha}${msg}`));
+  }
+  console.log(divider);
+  const statusColor = result.status === "passed" ? chalk.green : result.status === "failed" ? chalk.red : chalk.yellow;
+  const statusLabel = result.status === "timedout" ? "timed out" : result.status;
+  console.log(
+    row(
+      `${chalk.bold("Tests")}  ${statusColor(statusLabel.toUpperCase())}  ${chalk.dim(formatDuration(result.duration))}`
+    )
+  );
+  const counts = [];
+  if (data.testCounts.passed > 0) counts.push(chalk.green(`${data.testCounts.passed} passed`));
+  if (data.testCounts.failed > 0) counts.push(chalk.red(`${data.testCounts.failed} failed`));
+  if (data.testCounts.flaky > 0) counts.push(chalk.yellow(`${data.testCounts.flaky} flaky`));
+  if (data.testCounts.skipped > 0) counts.push(chalk.dim(`${data.testCounts.skipped} skipped`));
+  if (data.testCounts.timedOut > 0) counts.push(chalk.red(`${data.testCounts.timedOut} timed out`));
+  if (data.testCounts.interrupted > 0) counts.push(chalk.yellow(`${data.testCounts.interrupted} interrupted`));
+  const retriedStr = data.testCounts.retried > 0 ? `  ${chalk.dim(`(${data.testCounts.retried} retries)`)}` : "";
+  console.log(row(`       ${counts.join(chalk.dim(" \xB7 "))}  ${chalk.dim(`of ${data.totalTests}`)}${retriedStr}`));
+  console.log(divider);
+  const shardStr = data.shardInfo ? `${data.shardInfo.current}/${data.shardInfo.total}` : "\u2014";
+  console.log(
+    row(
+      `${pad(`${chalk.dim("Workers")}  ${data.workerCount > 0 ? data.workerCount : "\u2014"}`, 28)}${pad(`${chalk.dim("Shard")}  ${shardStr}`, 28)}${chalk.dim("Projects")}  ${data.projectNames.size > 0 ? Array.from(data.projectNames).join(", ") : "\u2014"}`
+    )
+  );
+  console.log(divider);
+  const transport = data.useHttpFallback ? "HTTP" : "WebSocket";
+  const streamIcon = streamingSuccess ? chalk.green("sent") : chalk.red("failed");
+  console.log(row(`${chalk.bold("Stream")}  ${streamIcon}  ${chalk.dim(`via ${transport}`)}`));
+  if (data.lastCoverageEvent) {
+    console.log(divider);
+    printCoverageTable(data.lastCoverageEvent);
+  }
+  console.log(bottomBorder);
+  console.log("");
+}
 var createReporterLog = (options) => ({
   success: (msg) => console.log(`\u2705 TestDino: ${msg}`),
   warn: (msg) => console.warn(`\u26A0\uFE0F  TestDino: ${msg}`),
@@ -1935,12 +2261,15 @@ var createReporterLog = (options) => ({
     if (options.debug) {
       console.log(`\u{1F50D} TestDino: ${msg}`);
     }
-  }
+  },
+  printRunSummary,
+  printCoverageTable
 });
 
 // src/reporter/index.ts
 var MAX_CONSOLE_CHUNK_SIZE = 1e4;
 var MAX_BUFFER_SIZE = 10;
+var COVERAGE_FILE_COUNT_WARNING = 500;
 var TestdinoReporter = class {
   config;
   wsClient = null;
@@ -1971,11 +2300,32 @@ var TestdinoReporter = class {
   pendingTestEndPromises = /* @__PURE__ */ new Set();
   // Logger for consistent output
   log;
+  // Coverage collection
+  coverageEnabled = false;
+  coverageMerger = null;
+  warnedCoverageDisconnect = false;
+  coverageThresholdFailed = false;
+  // Test result tracking for summary
+  testCounts = { passed: 0, failed: 0, skipped: 0, timedOut: 0, interrupted: 0, flaky: 0, retried: 0 };
+  totalTests = 0;
+  lastCoverageEvent = null;
+  // Detailed tracking for summary output
+  projectNames = /* @__PURE__ */ new Set();
+  runMetadata = null;
+  workerCount = 0;
   constructor(config = {}) {
     const cliConfig = this.loadCliConfig();
     this.config = { ...config, ...cliConfig };
     this.runId = randomUUID();
     this.log = createReporterLog({ debug: this.config.debug ?? false });
+    this.coverageEnabled = this.config.coverage?.enabled ?? false;
+    if (this.coverageEnabled) {
+      this.coverageMerger = new CoverageMerger({
+        include: this.config.coverage?.include,
+        exclude: this.config.coverage?.exclude,
+        onError: (msg) => this.log.warn(msg)
+      });
+    }
     this.buffer = new EventBuffer({
       maxSize: MAX_BUFFER_SIZE,
       onFlush: async (events) => {
@@ -2017,6 +2367,9 @@ var TestdinoReporter = class {
       if (cliConfig.artifacts !== void 0 && typeof cliConfig.artifacts === "boolean") {
         mappedConfig.artifacts = cliConfig.artifacts;
       }
+      if (typeof cliConfig.coverage === "object" && cliConfig.coverage !== null) {
+        mappedConfig.coverage = cliConfig.coverage;
+      }
       return mappedConfig;
     } catch (error) {
       if (isDebugEnabled()) {
@@ -2071,6 +2424,8 @@ var TestdinoReporter = class {
     const serverUrl = this.getServerUrl();
     try {
       const metadata = await this.collectMetadata(config, suite);
+      this.runMetadata = metadata;
+      this.workerCount = config.workers;
       this.httpClient = new HttpClient({ token, serverUrl });
       const auth = await this.httpClient.authenticate();
       this.sessionId = auth.sessionId;
@@ -2156,35 +2511,35 @@ var TestdinoReporter = class {
   /**
    * Called for each test before it starts
    */
-  async onTestBegin(test, result) {
+  async onTestBegin(test2, result) {
     if (!this.initPromise || this.initFailed) return;
     const event = {
       type: "test:begin",
       runId: this.runId,
       ...this.getEventMetadata(),
       // Test identification
-      testId: test.id,
-      title: test.title,
-      titlePath: test.titlePath(),
+      testId: test2.id,
+      title: test2.title,
+      titlePath: test2.titlePath(),
       // Location information
       location: {
-        file: test.location.file,
-        line: test.location.line,
-        column: test.location.column
+        file: test2.location.file,
+        line: test2.location.line,
+        column: test2.location.column
       },
       // Test configuration
-      tags: test.tags,
-      expectedStatus: test.expectedStatus,
-      timeout: test.timeout,
-      retries: test.retries,
-      annotations: this.extractAnnotations(test.annotations),
+      tags: test2.tags,
+      expectedStatus: test2.expectedStatus,
+      timeout: test2.timeout,
+      retries: test2.retries,
+      annotations: this.extractAnnotations(test2.annotations),
       // Execution context
       retry: result.retry,
       workerIndex: result.workerIndex,
       parallelIndex: result.parallelIndex,
-      repeatEachIndex: test.repeatEachIndex,
+      repeatEachIndex: test2.repeatEachIndex,
       // Hierarchy information
-      parentSuite: this.extractParentSuite(test.parent),
+      parentSuite: this.extractParentSuite(test2.parent),
       // Timing
       startTime: result.startTime.getTime()
     };
@@ -2193,15 +2548,15 @@ var TestdinoReporter = class {
   /**
    * Called when a test step begins
    */
-  async onStepBegin(test, result, step) {
+  async onStepBegin(test2, result, step) {
     if (!this.initPromise || this.initFailed) return;
     const event = {
       type: "step:begin",
       runId: this.runId,
       ...this.getEventMetadata(),
       // Step Identification
-      testId: test.id,
-      stepId: `${test.id}-${step.titlePath().join("-")}`,
+      testId: test2.id,
+      stepId: `${test2.id}-${step.titlePath().join("-")}`,
       title: step.title,
       titlePath: step.titlePath(),
       // Step Classification
@@ -2229,7 +2584,7 @@ var TestdinoReporter = class {
   /**
    * Called when a test step ends
    */
-  async onStepEnd(test, result, step) {
+  async onStepEnd(test2, result, step) {
     if (!this.initPromise || this.initFailed) return;
     const status = step.error ? "failed" : "passed";
     const event = {
@@ -2237,8 +2592,8 @@ var TestdinoReporter = class {
       runId: this.runId,
       ...this.getEventMetadata(),
       // Step Identification
-      testId: test.id,
-      stepId: `${test.id}-${step.titlePath().join("-")}`,
+      testId: test2.id,
+      stepId: `${test2.id}-${step.titlePath().join("-")}`,
       title: step.title,
       titlePath: step.titlePath(),
       // Timing
@@ -2265,9 +2620,46 @@ var TestdinoReporter = class {
    * Called after each test.
    * Playwright does not await onTestEnd promises—pending work is awaited in onEnd.
    */
-  onTestEnd(test, result) {
+  onTestEnd(test2, result) {
     if (!this.initPromise || this.initFailed) return;
-    const workPromise = this.processTestEnd(test, result);
+    if (!this.coverageEnabled && !this.warnedCoverageDisconnect) {
+      const hasCoverageAttachment = result.attachments.some((a) => a.name === "testdino-coverage");
+      if (hasCoverageAttachment) {
+        this.log.warn(
+          "Coverage data detected but coverage.enabled is false \u2014 set coverage: { enabled: true } to collect coverage"
+        );
+        this.warnedCoverageDisconnect = true;
+      }
+    }
+    if (this.coverageEnabled && this.coverageMerger) {
+      this.extractCoverageFromResult(test2, result, this.coverageMerger);
+    }
+    const projectName = this.getProjectName(test2);
+    if (projectName) {
+      this.projectNames.add(projectName);
+    }
+    if (result.retry > 0) {
+      this.testCounts.retried++;
+    }
+    const isFinalAttempt = result.status === "passed" || result.retry === test2.retries;
+    if (isFinalAttempt) {
+      this.totalTests++;
+      const outcome = test2.outcome();
+      if (outcome === "flaky") {
+        this.testCounts.flaky++;
+      } else if (result.status === "passed") {
+        this.testCounts.passed++;
+      } else if (result.status === "failed") {
+        this.testCounts.failed++;
+      } else if (result.status === "skipped") {
+        this.testCounts.skipped++;
+      } else if (result.status === "timedOut") {
+        this.testCounts.timedOut++;
+      } else if (result.status === "interrupted") {
+        this.testCounts.interrupted++;
+      }
+    }
+    const workPromise = this.processTestEnd(test2, result);
     this.pendingTestEndPromises.add(workPromise);
     workPromise.finally(() => {
       this.pendingTestEndPromises.delete(workPromise);
@@ -2277,18 +2669,18 @@ var TestdinoReporter = class {
    * Process test end event asynchronously
    * Uploads attachments and adds test:end event to buffer
    */
-  async processTestEnd(test, result) {
+  async processTestEnd(test2, result) {
     try {
-      const attachmentsWithUrls = await this.uploadAttachments(result.attachments, test.id);
+      const attachmentsWithUrls = await this.uploadAttachments(result.attachments, test2.id);
       const event = {
         type: "test:end",
         runId: this.runId,
         ...this.getEventMetadata(),
         // Test Identification
-        testId: test.id,
+        testId: test2.id,
         // Status Information
         status: result.status,
-        outcome: test.outcome(),
+        outcome: test2.outcome(),
         // Timing
         duration: result.duration,
         // Execution Context
@@ -2339,6 +2731,43 @@ var TestdinoReporter = class {
       this.log.debug(`Waiting for ${this.pendingTestEndPromises.size} pending test:end events...`);
       await Promise.allSettled(Array.from(this.pendingTestEndPromises));
     }
+    if (this.coverageEnabled && this.coverageMerger?.hasCoverage) {
+      try {
+        if (this.projectNames.size > 1 && !this.config.coverage?.projects?.length) {
+          this.log.warn(
+            `Coverage collected from ${this.projectNames.size} projects (${Array.from(this.projectNames).join(", ")}). Set coverage.projects to a single project to avoid duplicate counts`
+          );
+        }
+        if (this.config.coverage?.projects?.length) {
+          const unmatched = this.config.coverage.projects.filter((p) => !this.projectNames.has(p));
+          if (unmatched.length > 0) {
+            this.log.warn(
+              `coverage.projects contains unmatched values: ${unmatched.join(", ")}. Available projects: ${Array.from(this.projectNames).join(", ")}`
+            );
+          }
+        }
+        const coverageEvent = this.buildCoverageEvent(this.coverageMerger);
+        await this.buffer.add(coverageEvent);
+        this.lastCoverageEvent = coverageEvent;
+        const thresholdFailures = this.checkCoverageThresholds(coverageEvent.summary);
+        if (thresholdFailures.length > 0) {
+          this.coverageThresholdFailed = true;
+        }
+        if (this.config.coverage?.localReport) {
+          const outputDir = this.config.coverage.localReportDir || "./testdino-coverage";
+          const reportPath = await generateIstanbulHtmlReport(this.coverageMerger, {
+            outputDir
+          });
+          this.log.info(`Coverage Report: ${reportPath}`);
+        }
+      } catch (error) {
+        this.log.warn(`Failed to build coverage event: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } else if (this.coverageEnabled && !this.coverageMerger?.hasCoverage) {
+      this.log.warn(
+        "Coverage enabled but no data was collected. Ensure your app is instrumented with Istanbul (babel-plugin-istanbul) and tests use { test } from @testdino/playwright"
+      );
+    }
     const event = {
       type: "run:end",
       runId: this.runId,
@@ -2389,6 +2818,28 @@ var TestdinoReporter = class {
         this.log.error(`Failed to send run:end event: ${errorMessage}`);
       }
     }
+    const summaryData = {
+      runId: this.runId,
+      runMetadata: this.runMetadata,
+      testCounts: this.testCounts,
+      totalTests: this.totalTests,
+      workerCount: this.workerCount,
+      projectNames: this.projectNames,
+      shardInfo: this.shardInfo,
+      useHttpFallback: this.useHttpFallback,
+      lastCoverageEvent: this.lastCoverageEvent
+    };
+    this.log.printRunSummary(result, delivered, summaryData);
+    if (this.coverageThresholdFailed && this.lastCoverageEvent) {
+      const failures = this.checkCoverageThresholds(this.lastCoverageEvent.summary);
+      this.log.error("Coverage thresholds not met:");
+      for (const msg of failures) {
+        this.log.error(`  ${msg}`);
+      }
+      this.wsClient?.close();
+      this.removeSignalHandlers();
+      return { status: "failed" };
+    }
     this.wsClient?.close();
     this.removeSignalHandlers();
   }
@@ -2409,7 +2860,7 @@ var TestdinoReporter = class {
   /**
    * Called when standard output is produced in worker process
    */
-  async onStdOut(chunk, test, result) {
+  async onStdOut(chunk, test2, result) {
     if (!this.initPromise || this.initFailed) return;
     const { text, truncated } = this.truncateChunk(chunk);
     const event = {
@@ -2419,7 +2870,7 @@ var TestdinoReporter = class {
       // Console Output
       text,
       // Test Association (optional)
-      testId: test?.id,
+      testId: test2?.id,
       retry: result?.retry,
       // Truncation Indicator
       truncated
@@ -2429,7 +2880,7 @@ var TestdinoReporter = class {
   /**
    * Called when standard error is produced in worker process
    */
-  async onStdErr(chunk, test, result) {
+  async onStdErr(chunk, test2, result) {
     if (!this.initPromise || this.initFailed) return;
     const { text, truncated } = this.truncateChunk(chunk);
     const event = {
@@ -2439,7 +2890,7 @@ var TestdinoReporter = class {
       // Console Error Output
       text,
       // Test Association (optional)
-      testId: test?.id,
+      testId: test2?.id,
       retry: result?.retry,
       // Truncation Indicator
       truncated
@@ -2998,8 +3449,98 @@ var TestdinoReporter = class {
   getBaseServerUrl(serverUrl) {
     return serverUrl.replace(/\/api\/reporter$/, "");
   }
+  /**
+   * Walk up the suite hierarchy to find the project name for a test.
+   */
+  getProjectName(test2) {
+    let suite = test2.parent;
+    while (suite) {
+      const project = suite.project();
+      if (project) {
+        return project.name || project.use?.defaultBrowserType || "default";
+      }
+      suite = suite.parent;
+    }
+    return void 0;
+  }
+  /**
+   * Extract coverage fragment from test result attachments and merge incrementally.
+   * The fixture attaches coverage as an in-memory JSON attachment named 'testdino-coverage'.
+   *
+   * Respects coverage.projects filter to avoid duplicate coverage from multiple browser projects.
+   */
+  extractCoverageFromResult(test2, result, merger) {
+    if (this.config.coverage?.projects) {
+      const projectName = this.getProjectName(test2);
+      if (projectName && !this.config.coverage.projects.includes(projectName)) {
+        return;
+      }
+    }
+    const coverageAttachment = result.attachments.find((a) => a.name === "testdino-coverage");
+    if (!coverageAttachment?.body) return;
+    try {
+      const fragment = JSON.parse(coverageAttachment.body.toString());
+      merger.addFragment(fragment);
+    } catch (error) {
+      this.log.debug(
+        `Malformed coverage attachment, skipping: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Build a coverage:data event from the merged coverage data.
+   *
+   * Non-sharded runs: summary + per-file metrics only (small payload).
+   * Sharded runs: also includes compact hit counts for server-side cross-shard merging.
+   */
+  buildCoverageEvent(merger) {
+    const rootDir = this.runMetadata?.playwright?.rootDir || process.cwd();
+    const summary = merger.computeSummary();
+    const files = merger.computeFileCoverage(rootDir);
+    const isSharded = !!this.shardInfo;
+    if (files.length > COVERAGE_FILE_COUNT_WARNING) {
+      this.log.warn(`Coverage includes ${files.length} files \u2014 consider using coverage.projects to reduce scope`);
+    }
+    const event = {
+      type: "coverage:data",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      summary,
+      files,
+      metadata: {
+        instrumentationType: "istanbul",
+        fileCount: files.length,
+        sharded: isSharded
+      }
+    };
+    if (isSharded) {
+      const coverageMapJSON = merger.toJSON();
+      event.compactCounts = extractCompactCounts(coverageMapJSON, rootDir);
+      event.shard = this.shardInfo;
+    }
+    return event;
+  }
+  /**
+   * Check coverage against configured thresholds.
+   * Returns an array of failure messages (empty if all thresholds pass).
+   */
+  checkCoverageThresholds(summary) {
+    const thresholds = this.config.coverage?.thresholds;
+    if (!thresholds) return [];
+    const failures = [];
+    const check = (name, actual, threshold) => {
+      if (threshold !== void 0 && actual < threshold) {
+        failures.push(`${name}: ${actual.toFixed(2)}% < ${threshold}%`);
+      }
+    };
+    check("Statements", summary.statements.pct, thresholds.statements);
+    check("Branches", summary.branches.pct, thresholds.branches);
+    check("Functions", summary.functions.pct, thresholds.functions);
+    check("Lines", summary.lines.pct, thresholds.lines);
+    return failures;
+  }
 };
 
-export { TestdinoReporter as default };
+export { coverageFixtures, TestdinoReporter as default, test };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map