@arpanp/zen-reporter 0.10.1

package/dist/reporter.js

@@ -0,0 +1,846 @@
+import { createRequire } from "node:module";
+import { execFileSync, execSync } from "child_process";
+import * as fs from "fs";
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+import { resolve } from "path";
+import * as readline from "readline";
+import { fileURLToPath } from "url";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/lib/utils.ts
+var customFsInstance = null;
+function setFsModule(fsInstance) {
+	customFsInstance = fsInstance;
+}
+function getNodeFs() {
+	if (typeof window !== "undefined") return null;
+	if (customFsInstance) return customFsInstance;
+	try {
+		const proc = typeof process !== "undefined" ? process : void 0;
+		if (proc && typeof proc.getBuiltinModule === "function") {
+			const builtinFs = proc.getBuiltinModule("fs");
+			if (builtinFs) return builtinFs;
+		}
+		const g = globalThis;
+		if (typeof g.require === "function") return g.require("fs");
+	} catch {
+		return null;
+	}
+	return null;
+}
+var fileSnippetCache = /* @__PURE__ */ new Map();
+function getStepCodeSnippet(location, fsModule) {
+	if (!location || !location.file || !location.line) return;
+	try {
+		const fs = fsModule || getNodeFs();
+		if (!fs) return void 0;
+		let filePath = location.file;
+		if (!fs.existsSync(filePath)) {
+			const resolved = typeof process !== "undefined" && process.cwd ? `${process.cwd()}/${filePath}` : filePath;
+			if (fs.existsSync(resolved)) filePath = resolved;
+			else return;
+		}
+		let lines = fileSnippetCache.get(filePath);
+		if (!lines) {
+			lines = fs.readFileSync(filePath, "utf8").split(/\r?\n/);
+			fileSnippetCache.set(filePath, lines);
+		}
+		const targetLine = location.line;
+		if (targetLine < 1 || targetLine > lines.length) return void 0;
+		const startLine = Math.max(1, targetLine - 1);
+		const endLine = Math.min(lines.length, targetLine + 1);
+		const snippetLines = [];
+		for (let l = startLine; l <= endLine; l++) {
+			const prefix = l === targetLine ? ">" : " ";
+			const lineNum = String(l).padStart(4, " ");
+			snippetLines.push(`${prefix} ${lineNum} | ${lines[l - 1]}`);
+		}
+		return snippetLines.join("\n");
+	} catch {}
+}
+function convertPlaywrightSteps(pwSteps, fsModule) {
+	const activeFs = fsModule || getNodeFs();
+	return pwSteps.map((step) => {
+		const rawStep = step;
+		const rawError = step.error;
+		const error = step.error ? {
+			name: "Error",
+			message: step.error.message ?? "",
+			stack: step.error.stack || "",
+			location: step.error.location ? {
+				file: step.error.location.file,
+				line: step.error.location.line,
+				column: step.error.location.column
+			} : null,
+			snippet: step.error.snippet || "",
+			cause: rawError?.cause || null
+		} : null;
+		const status = step.error ? "failed" : "passed";
+		const location = step.location ? {
+			file: step.location.file,
+			line: step.location.line,
+			column: step.location.column
+		} : null;
+		const snippet = (typeof rawStep.snippet === "string" ? rawStep.snippet : void 0) || getStepCodeSnippet(location, activeFs);
+		const rawParams = rawStep.params;
+		const params = rawParams && typeof rawParams === "object" ? rawParams : void 0;
+		return {
+			title: step.title,
+			subtitle: typeof rawStep.subtitle === "string" ? rawStep.subtitle : void 0,
+			location,
+			snippet,
+			params,
+			duration: step.duration,
+			status,
+			annotations: Array.isArray(rawStep.annotations) ? rawStep.annotations : [],
+			attachments: step.attachments ? step.attachments.map((att) => {
+				let bodyData = null;
+				if (att.body) bodyData = Buffer.isBuffer(att.body) ? att.body.toString("base64") : typeof att.body === "string" ? att.body : Buffer.from(att.body).toString("base64");
+				else if (att.path) {
+					if (activeFs && activeFs.existsSync(att.path)) try {
+						bodyData = activeFs.readFileSync(att.path).toString("base64");
+					} catch {}
+				}
+				return {
+					name: att.name,
+					contentType: att.contentType,
+					path: att.path || null,
+					body: bodyData
+				};
+			}) : [],
+			error,
+			subSteps: step.steps && step.steps.length > 0 ? convertPlaywrightSteps(step.steps, activeFs) : void 0
+		};
+	});
+}
+function sanitizeAnsi(str) {
+	return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function buildHierarchyForFile(fileName, cases) {
+	const rootSuite = {
+		title: fileName,
+		cases: [],
+		subSuites: []
+	};
+	for (const tc of cases) {
+		const describePath = tc.describePath || (tc.parent && tc.parent !== tc.fileName ? [tc.parent] : []);
+		let currentSuite = rootSuite;
+		for (const title of describePath) {
+			if (!currentSuite.subSuites) currentSuite.subSuites = [];
+			let child = currentSuite.subSuites.find((s) => s.title === title);
+			if (!child) {
+				child = {
+					title,
+					cases: [],
+					subSuites: []
+				};
+				currentSuite.subSuites.push(child);
+			}
+			currentSuite = child;
+		}
+		currentSuite.cases.push(tc);
+	}
+	return rootSuite;
+}
+function buildSuitesFromCases(testCases) {
+	const fileGroups = {};
+	for (const tc of testCases) {
+		const key = tc.fileName || "unknown file";
+		if (!fileGroups[key]) fileGroups[key] = [];
+		fileGroups[key].push(tc);
+	}
+	const suites = [];
+	for (const [fileName, cases] of Object.entries(fileGroups)) suites.push(buildHierarchyForFile(fileName, cases));
+	return suites;
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	const seconds = Math.floor(ms / 1e3);
+	const minutes = Math.floor(seconds / 60);
+	const secs = seconds % 60;
+	if (minutes > 0) return `${minutes}m ${secs}s`;
+	return `${secs}s`;
+}
+function generateTerminalSummaryTable(summary, projectName, testRunName) {
+	const total = summary.total || 0;
+	const passed = summary.passed || 0;
+	const failed = summary.failed || 0;
+	const timedOut = summary.timedOut || 0;
+	const skipped = summary.skipped || 0;
+	const interrupted = summary.interrupted || 0;
+	const statusStr = failed > 0 || timedOut > 0 || interrupted > 0 ? "FAILED" : "PASSED";
+	const passRate = total > 0 ? `${(passed / total * 100).toFixed(1).replace(/\.0$/, "")}%` : "0%";
+	const durationStr = formatDuration(summary.duration || 0);
+	const headers = [
+		"Status",
+		"Duration",
+		"Pass Rate",
+		"Total",
+		"Passed",
+		"Failed",
+		"Timed Out",
+		"Skipped"
+	];
+	const values = [
+		statusStr,
+		durationStr,
+		passRate,
+		String(total),
+		String(passed),
+		String(failed),
+		String(timedOut),
+		String(skipped)
+	];
+	if (interrupted > 0) {
+		headers.push("Interrupted");
+		values.push(String(interrupted));
+	}
+	const widths = headers.map((h, i) => Math.max(h.length, values[i].length));
+	const border = `+${widths.map((w) => "-".repeat(w + 2)).join("+")}+`;
+	const formatRow = (cells) => `| ${cells.map((c, i) => c.padEnd(widths[i])).join(" | ")} |`;
+	return `${`Test Summary: ${projectName || "Test Automation Project"} — ${testRunName || "Test Run"}`}\n${border}\n${formatRow(headers)}\n${border}\n${formatRow(values)}\n${border}`;
+}
+//#endregion
+//#region src/lib/dataProcessor.ts
+function detectPackageManager(cwd = process.cwd()) {
+	for (const [file, manager] of [
+		["pnpm-lock.yaml", "pnpm"],
+		["yarn.lock", "yarn"],
+		["bun.lock", "bun"],
+		["package-lock.json", "npm"]
+	]) if (existsSync(resolve(cwd, file))) return manager;
+	if (existsSync(resolve(cwd, ".npmrc"))) return "npm";
+	try {
+		const pkgPath = resolve(cwd, "package.json");
+		if (existsSync(pkgPath)) {
+			const pkgJson = JSON.parse(readFileSync(pkgPath, "utf8"));
+			if (pkgJson.packageManager) return pkgJson.packageManager.split("@")[0];
+		}
+	} catch {}
+	return "npm";
+}
+function getViteBuildCommand(pm, cwd = process.cwd()) {
+	switch (pm || detectPackageManager(cwd)) {
+		case "pnpm": return "pnpm exec vite build";
+		case "yarn": return "yarn exec vite build";
+		case "bun": return "bunx vite build";
+		default: return "npx vite build";
+	}
+}
+//#endregion
+//#region src/lib/runHistory.ts
+/**
+* Exact ordered field list for a single history row (single source of truth
+* for the JSONL row shape that DuckDB's read_json consumes).
+*/
+var RUN_ROW_FIELDS = [
+	"run_id",
+	"run_name",
+	"project_name",
+	"started_at",
+	"ended_at",
+	"run_duration_ms",
+	"run_sequential_duration_ms",
+	"run_interrupted",
+	"run_passed",
+	"run_failed",
+	"run_skipped",
+	"run_timed_out",
+	"run_interrupted",
+	"run_workers",
+	"run_projects",
+	"file",
+	"suite",
+	"title",
+	"project",
+	"status",
+	"duration_ms",
+	"attempts",
+	"failed_attempts",
+	"passed_on_retry",
+	"error_message",
+	"error_stack",
+	"error_file",
+	"error_line",
+	"tags"
+];
+/** Lowercase, trim, every non-alphanumeric run -> single '-', strip edge '-'. */
+function slugify(name) {
+	return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+* Deterministic run identifier: ISO start time (colons/dots -> '-') + slugified
+* test run name, plus a shard suffix when running sharded.
+*/
+function buildRunId(startedAtIso, testRunName, shard) {
+	const base = `${startedAtIso.replace(/[:.]/g, "-")}__${slugify(testRunName)}`;
+	if (shard && shard.total > 1) return `${base}__shard${shard.current}of${shard.total}`;
+	return base;
+}
+/**
+* One row per test case, each carrying the run-level fields plus the per-test
+* fields, so DuckDB can group/join across runs on the uniform schema.
+*/
+function flattenRunRows(runId, testRunName, projectName, summary, endedAt, testCases) {
+	const runLevel = {
+		run_id: runId,
+		run_name: testRunName,
+		project_name: projectName,
+		started_at: summary.startTime,
+		ended_at: endedAt,
+		run_duration_ms: summary.duration,
+		run_sequential_duration_ms: summary.totalSequentialDuration ?? null,
+		run_total: summary.total,
+		run_passed: summary.passed,
+		run_failed: summary.failed,
+		run_skipped: summary.skipped,
+		run_timed_out: summary.timedOut,
+		run_interrupted: summary.interrupted ?? 0,
+		run_workers: summary.workers ?? null,
+		run_projects: summary.numberOfProjects
+	};
+	if (testCases.length === 0) {
+		const row = { ...runLevel };
+		for (const field of RUN_ROW_FIELDS) if (!(field in row)) row[field] = null;
+		return [row];
+	}
+	return testCases.map((tc) => {
+		const row = { ...runLevel };
+		row.file = tc.fileName;
+		row.suite = (tc.describePath?.length ? tc.describePath.join(" > ") : tc.parent) || "";
+		row.title = tc.title;
+		row.project = tc.project;
+		row.status = tc.status;
+		row.duration_ms = Math.round(tc.duration);
+		row.attempts = tc.attempts ?? 0;
+		row.failed_attempts = tc.failedAttempts?.length ?? 0;
+		row.passed_on_retry = (tc.attempts ?? 0) > 1 && tc.status === "passed";
+		row.error_message = tc.errors?.[0]?.message ?? null;
+		row.error_stack = tc.errors?.[0]?.stack ?? null;
+		row.error_file = tc.errors?.[0]?.location?.file ?? null;
+		row.error_line = tc.errors?.[0]?.location?.line ?? null;
+		row.tags = tc.tags ?? [];
+		return row;
+	});
+}
+//#endregion
+//#region src/lib/reporter.ts
+setFsModule(fs);
+function getDescribePath(test) {
+	const path = [];
+	let curr = test.parent;
+	while (curr) {
+		if (curr.type === "file" || curr.type === "project" || curr.type === "root") break;
+		if (curr.type === "describe" && curr.title) path.unshift(curr.title);
+		curr = curr.parent;
+	}
+	return path;
+}
+function resolveConfig(rawConfig, cwd = process.cwd()) {
+	const outputDir = rawConfig?.outputDir ? String(rawConfig.outputDir) : "zen-report";
+	const packageManager = detectPackageManager(cwd);
+	const projectName = rawConfig?.projectName ? String(rawConfig.projectName) : "Test Automation Project";
+	let runNumber = 1;
+	try {
+		const runsDir = path.resolve(cwd, outputDir, "runs");
+		if (fs.existsSync(runsDir)) runNumber = fs.readdirSync(runsDir).filter((f) => f.endsWith(".jsonl")).length + 1;
+	} catch {
+		runNumber = 1;
+	}
+	const testRunName = (rawConfig?.testRunName ? String(rawConfig.testRunName) : "Test Run #{N}").replaceAll("{N}", String(runNumber));
+	const singleSummaryFile = Boolean(rawConfig?.singleSummaryFile);
+	const theme = rawConfig?.theme !== void 0 ? String(rawConfig.theme) : "Cafe";
+	const darkMode = Boolean(rawConfig?.darkMode);
+	const minimalReport = Boolean(rawConfig?.minimalReport);
+	let enableHistory = "auto";
+	if (minimalReport) enableHistory = false;
+	else if (rawConfig?.enableHistory !== void 0) {
+		if (typeof rawConfig.enableHistory === "boolean") enableHistory = rawConfig.enableHistory;
+		else if (rawConfig.enableHistory === "auto") enableHistory = "auto";
+	}
+	let consoleProgress = "auto";
+	if (rawConfig?.consoleProgress !== void 0) {
+		if (typeof rawConfig.consoleProgress === "boolean") consoleProgress = rawConfig.consoleProgress;
+		else if (rawConfig.consoleProgress === "auto" || rawConfig.consoleProgress === "line" || rawConfig.consoleProgress === "dot") consoleProgress = rawConfig.consoleProgress;
+	}
+	return {
+		outputDir,
+		packageManager,
+		projectName,
+		testRunName,
+		singleSummaryFile,
+		theme,
+		darkMode,
+		enableHistory,
+		minimalReport,
+		consoleProgress
+	};
+}
+var ZenReporter = class {
+	constructor(options) {
+		this.testCaseMap = /* @__PURE__ */ new Map();
+		this.startTime = "";
+		this.testCases = [];
+		this.totalTests = 0;
+		this.completedTests = 0;
+		this.completedTestIds = /* @__PURE__ */ new Set();
+		this.passedCount = 0;
+		this.failedCount = 0;
+		this.timedOutCount = 0;
+		this.skippedCount = 0;
+		this.activeWorkers = /* @__PURE__ */ new Set();
+		this.lastCompletedTest = "";
+		this.dotLineLength = 0;
+		this.progressMode = "none";
+		this.options = options;
+	}
+	printLineProgress() {
+		if (this.progressMode !== "line") return;
+		if (!(typeof process !== "undefined" && process.stdout && Boolean(process.stdout.isTTY))) return;
+		const pct = this.totalTests > 0 ? Math.floor(this.completedTests / this.totalTests * 100) : 0;
+		const workersCount = this.activeWorkers.size;
+		const workerStr = `${workersCount} active worker${workersCount === 1 ? "" : "s"}`;
+		let line = `[ ${this.completedTests}/${this.totalTests} ] ${pct}% | ✅ ${this.passedCount} | ❌ ${this.failedCount + this.timedOutCount} | ⏭️ ${this.skippedCount} (${workerStr})`;
+		if (this.lastCompletedTest) line += ` | Last: ${this.lastCompletedTest}`;
+		const cols = process.stdout.columns || 100;
+		if (line.length > cols - 1) line = line.slice(0, Math.max(10, cols - 4)) + "...";
+		readline.clearLine(process.stdout, 0);
+		readline.cursorTo(process.stdout, 0);
+		process.stdout.write(line);
+	}
+	clearLineProgress() {
+		if (this.progressMode === "line" && typeof process !== "undefined" && process.stdout && Boolean(process.stdout.isTTY)) {
+			readline.clearLine(process.stdout, 0);
+			readline.cursorTo(process.stdout, 0);
+		}
+	}
+	handleDotProgress(status) {
+		if (this.progressMode !== "dot") return;
+		const symbol = status === "failed" || status === "timedOut" || status === "interrupted" ? "F" : status === "skipped" ? "s" : status === "flaky" ? "±" : ".";
+		process.stdout.write(symbol);
+		this.dotLineLength += 1;
+		if (this.dotLineLength >= 80 || this.completedTestIds.size === this.totalTests) {
+			process.stdout.write(` [ ${this.completedTestIds.size}/${this.totalTests} ]\n`);
+			this.dotLineLength = 0;
+		}
+	}
+	buildSuites() {
+		return buildSuitesFromCases(this.testCases);
+	}
+	/**
+	* Persist every run as a self-contained per-run JSONL file under
+	* <outputDir>/runs/ so historic runs survive report rebuilds.
+	* Failure policy: catch-and-log only — history writing must never break
+	* report/HTML generation.
+	*/
+	writeRunHistory(summary, endedAt) {
+		try {
+			const runId = buildRunId(this.startTime, this.reportConfig.testRunName, this.config.shard);
+			const cwd = process.cwd();
+			const normalizedCwd = cwd.endsWith("/") ? cwd.slice(0, -1) : cwd;
+			const runsDir = path.resolve(normalizedCwd, this.reportConfig.outputDir, "runs");
+			let finalRunId = runId;
+			let suffix = 2;
+			while (fs.existsSync(path.join(runsDir, `${finalRunId}.jsonl`))) {
+				finalRunId = `${runId}-${suffix}`;
+				suffix += 1;
+			}
+			const rows = flattenRunRows(finalRunId, this.reportConfig.testRunName, this.reportConfig.projectName, summary, endedAt, this.testCases);
+			fs.mkdirSync(runsDir, { recursive: true });
+			fs.writeFileSync(path.join(runsDir, `${finalRunId}.jsonl`), rows.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf8");
+		} catch (e) {
+			console.error("Run history write failed:", e);
+		}
+	}
+	/**
+	* Regenerate `history.json` by running the CLI's `history report`
+	* subcommand (the CLI owns the DuckDB aggregate queries — single source
+	* of truth) and inject the fresh snapshot into `<outputDir>/index.html`.
+	* Runs after the new run's JSONL has been written, so it includes the
+	* just-finished run. Best-effort: any failure (missing @duckdb/node-api,
+	* missing bin, spawn error) is caught and logged; the snapshot that was
+	* re-injected above remains in the report.
+	*/
+	refreshHistory() {
+		try {
+			const moduleFile = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+			let dir = path.dirname(moduleFile);
+			let binPath = null;
+			for (let i = 0; i < 4; i++) {
+				const candidate = path.join(dir, "bin", "zen-reporter.js");
+				if (fs.existsSync(candidate)) {
+					binPath = candidate;
+					break;
+				}
+				const parent = path.dirname(dir);
+				if (parent === dir) break;
+				dir = parent;
+			}
+			if (!binPath) return;
+			execFileSync(process.execPath, [
+				binPath,
+				"history",
+				"report"
+			], {
+				cwd: process.cwd(),
+				stdio: "inherit",
+				env: {
+					...process.env,
+					PW_REPORTER_OUTPUT: this.reportConfig.outputDir
+				}
+			});
+		} catch {
+			console.warn("History refresh skipped (keeping existing history data).");
+		}
+	}
+	onBegin(config, suite) {
+		this.config = config;
+		this.reportConfig = resolveConfig(this.options || config.reporterConfig);
+		if (this.reportConfig.enableHistory === true) try {
+			__require.resolve("@duckdb/node-api");
+		} catch {
+			throw new Error("Zen Reporter: history is explicitly enabled (enableHistory: true), but \"@duckdb/node-api\" is not installed. Please install \"@duckdb/node-api\" or set enableHistory to \"auto\" or false.");
+		}
+		this.startTime = (/* @__PURE__ */ new Date()).toISOString();
+		this.testCaseMap.clear();
+		this.testCases = [];
+		const allTests = suite.allTests();
+		this.totalTests = allTests.length;
+		this.completedTests = 0;
+		this.completedTestIds.clear();
+		this.passedCount = 0;
+		this.failedCount = 0;
+		this.timedOutCount = 0;
+		this.skippedCount = 0;
+		this.activeWorkers.clear();
+		this.lastCompletedTest = "";
+		this.dotLineLength = 0;
+		const cp = this.reportConfig.consoleProgress;
+		if (cp === false) this.progressMode = "none";
+		else if (cp === "line") this.progressMode = "line";
+		else if (cp === "dot") this.progressMode = "dot";
+		else {
+			const isTTY = typeof process !== "undefined" && process.stdout && Boolean(process.stdout.isTTY);
+			this.progressMode = isTTY ? "line" : "dot";
+		}
+		if (this.progressMode === "dot") {
+			const workers = this.config.workers || 1;
+			const workerStr = workers === 1 ? "1 worker (serially)" : `${workers} workers (in parallel)`;
+			console.log(`Running total ${this.totalTests} tests, ${workerStr}\n\nLegend: . passed | F failed | ± flaky | s skipped\n`);
+		}
+		for (const test of allTests) {
+			const fileName = test.location?.file ? test.location.file.replace(process.cwd(), "") : "unknown file";
+			const testCase = {
+				title: test.title,
+				parent: test.parent.title,
+				project: test.parent.project()?.name || "unknown",
+				fileName,
+				status: "skipped",
+				duration: 0,
+				steps: [],
+				stdout: [],
+				stderr: [],
+				annotations: test.annotations ? test.annotations.map((a) => ({
+					type: a.type,
+					description: a.description || null,
+					location: a.location ? {
+						file: a.location.file,
+						line: a.location.line,
+						column: a.location.column
+					} : null
+				})) : [],
+				attachments: [],
+				tags: test.tags.flatMap((tag) => tag.replace("@", "")),
+				describePath: getDescribePath(test),
+				attempts: 0,
+				failedAttempts: []
+			};
+			testCase.tags?.push(testCase.project);
+			this.testCaseMap.set(test.id, testCase);
+		}
+	}
+	onTestBegin(test, _result) {
+		this.activeWorkers.add(test.id);
+		if (this.progressMode === "line") this.printLineProgress();
+		let existing = this.testCaseMap.get(test.id);
+		if (!existing) {
+			const fileName = test.parent.location?.file ? test.parent.location.file.replace(process.cwd(), "") : "unknown file";
+			existing = {
+				title: test.title,
+				parent: test.parent.title,
+				project: test.parent.project()?.name || "unknown",
+				fileName,
+				status: "passed",
+				duration: 0,
+				steps: [],
+				stdout: [],
+				stderr: [],
+				annotations: test.annotations ? test.annotations.map((a) => ({
+					type: a.type,
+					description: a.description || null,
+					location: a.location ? {
+						file: a.location.file,
+						line: a.location.line,
+						column: a.location.column
+					} : null
+				})) : [],
+				attachments: [],
+				tags: test.tags.flatMap((tag) => tag.replace("@", "")),
+				describePath: getDescribePath(test),
+				attempts: 0,
+				failedAttempts: []
+			};
+			existing.tags?.push(existing.project);
+			this.testCaseMap.set(test.id, existing);
+		}
+		existing.attempts = (existing.attempts ?? 0) + 1;
+	}
+	onTestEnd(test, result) {
+		const testCase = this.testCaseMap.get(test.id);
+		if (!testCase) return;
+		testCase.status = result.status === "passed" ? "passed" : result.status === "failed" ? "failed" : result.status === "skipped" ? "skipped" : result.status === "timedOut" ? "timedOut" : result.status === "interrupted" ? "interrupted" : "failed";
+		const attemptSteps = result.steps && result.steps.length > 0 ? convertPlaywrightSteps(result.steps, fs) : void 0;
+		const stepDurationSum = attemptSteps ? attemptSteps.reduce((sum, step) => sum + (step.duration || 0), 0) : 0;
+		const attemptDuration = typeof result.duration === "number" && result.duration > 0 ? result.duration : stepDurationSum;
+		testCase.duration = attemptDuration;
+		if (test.annotations) testCase.annotations = test.annotations.map((a) => ({
+			type: a.type,
+			description: a.description || null,
+			location: a.location ? {
+				file: a.location.file,
+				line: a.location.line,
+				column: a.location.column
+			} : null
+		}));
+		const attemptStdout = (result.stdout || []).map((entry) => typeof entry === "string" ? entry : entry.toString("utf8"));
+		const attemptStderr = (result.stderr || []).map((entry) => typeof entry === "string" ? entry : entry.toString("utf8"));
+		const cwd = process.cwd();
+		const normalizedCwd = cwd.endsWith("/") ? cwd.slice(0, -1) : cwd;
+		const outputDir = path.resolve(normalizedCwd, this.reportConfig.outputDir);
+		const attachmentsDir = path.join(outputDir, "attachments");
+		const attemptAttachments = (result.attachments || []).map((att, attIdx) => {
+			let bodyData = null;
+			let finalPath = att.path || null;
+			const isText = att.contentType?.startsWith("text/") || /\.(txt|log|json|csv|html|xml|md|yaml|yml|js|ts|jsx|tsx|css)$/i.test(att.name || att.path || "");
+			if (att.path && fs.existsSync(att.path)) try {
+				fs.mkdirSync(attachmentsDir, { recursive: true });
+				const safeName = path.basename(att.path).replace(/[^a-zA-Z0-9._-]/g, "_");
+				const targetFilename = `${test.id.replace(/[^a-zA-Z0-9_-]/g, "_")}_att${attIdx}_${safeName}`;
+				const targetPath = path.join(attachmentsDir, targetFilename);
+				fs.copyFileSync(att.path, targetPath);
+				finalPath = `./attachments/${targetFilename}`;
+				if (isText) bodyData = fs.readFileSync(att.path, "utf8");
+			} catch (e) {
+				console.error(`Failed to copy attachment file from ${att.path}:`, e);
+			}
+			else if (att.body) {
+				if (isText) bodyData = Buffer.isBuffer(att.body) ? att.body.toString("utf8") : typeof att.body === "string" ? att.body : String(att.body);
+				else try {
+					fs.mkdirSync(attachmentsDir, { recursive: true });
+					const ext = att.contentType === "image/png" ? ".png" : att.contentType === "image/jpeg" ? ".jpg" : ".bin";
+					const targetFilename = `${test.id.replace(/[^a-zA-Z0-9_-]/g, "_")}_att${attIdx}${ext}`;
+					const targetPath = path.join(attachmentsDir, targetFilename);
+					const buf = Buffer.isBuffer(att.body) ? att.body : Buffer.from(att.body);
+					fs.writeFileSync(targetPath, buf);
+					finalPath = `./attachments/${targetFilename}`;
+				} catch (e) {
+					console.error("Failed to write in-memory attachment to disk:", e);
+				}
+			}
+			return {
+				name: att.name,
+				contentType: att.contentType,
+				path: finalPath,
+				body: bodyData
+			};
+		});
+		testCase.attachments = attemptAttachments.length > 0 ? attemptAttachments : void 0;
+		testCase.errors = result.error ? [{
+			name: "Error",
+			message: sanitizeAnsi(result.error.message || ""),
+			stack: sanitizeAnsi(result.error.stack || ""),
+			location: result.error.location ? {
+				file: result.error.location.file,
+				line: result.error.location.line,
+				column: result.error.location.column
+			} : null,
+			snippet: result.error.snippet || "",
+			cause: result.error.cause || null
+		}] : void 0;
+		if (result.status === "failed" || result.status === "timedOut" || result.status === "interrupted") {
+			testCase.failedAttempts = testCase.failedAttempts ?? [];
+			testCase.failedAttempts.push({
+				status: result.status,
+				duration: attemptDuration,
+				error: testCase.errors && testCase.errors.length > 0 ? testCase.errors[0] : null,
+				steps: attemptSteps,
+				stdout: attemptStdout.length > 0 ? attemptStdout : void 0,
+				stderr: attemptStderr.length > 0 ? attemptStderr : void 0,
+				attachments: attemptAttachments.length > 0 ? attemptAttachments : void 0
+			});
+		}
+		testCase.steps = attemptSteps;
+		testCase.stdout = attemptStdout.length > 0 ? attemptStdout : void 0;
+		testCase.stderr = attemptStderr.length > 0 ? attemptStderr : void 0;
+		this.activeWorkers.delete(test.id);
+		this.completedTestIds.add(test.id);
+		this.completedTests = this.completedTestIds.size;
+		const status = testCase.status;
+		if (status === "passed") this.passedCount += 1;
+		else if (status === "failed") this.failedCount += 1;
+		else if (status === "timedOut") this.timedOutCount += 1;
+		else if (status === "skipped") this.skippedCount += 1;
+		const shortName = `${testCase.project && testCase.project !== "unknown" ? `[${testCase.project}] ` : ""}${testCase.fileName} › ${testCase.title}`;
+		this.lastCompletedTest = shortName;
+		if (this.progressMode === "line") {
+			if (status === "failed" || status === "timedOut" || status === "interrupted") {
+				this.clearLineProgress();
+				const durationStr = testCase.duration > 0 ? ` (${testCase.duration}ms)` : "";
+				console.log(`❌ [FAILED] ${shortName}${durationStr}`);
+			}
+			this.printLineProgress();
+		} else if (this.progressMode === "dot") {
+			let dotStatus = status;
+			if (status === "passed" && (testCase.failedAttempts?.length ?? 0) > 0) dotStatus = "flaky";
+			this.handleDotProgress(dotStatus);
+		}
+	}
+	onEnd(result) {
+		if (this.progressMode === "line") this.clearLineProgress();
+		else if (this.progressMode === "dot") {
+			if (this.dotLineLength > 0) {
+				process.stdout.write(` [ ${this.completedTests}/${this.totalTests} ]\n`);
+				this.dotLineLength = 0;
+			}
+		}
+		if (result.status === "interrupted") {
+			for (const testCase of this.testCaseMap.values()) if ((testCase.attempts ?? 0) === 0) testCase.status = "interrupted";
+		}
+		this.testCases = Array.from(this.testCaseMap.values());
+		const endTime = (/* @__PURE__ */ new Date()).toISOString();
+		const startTimeMs = new Date(this.startTime).getTime();
+		const endTimeMs = new Date(endTime).getTime();
+		const wallClockDuration = Math.max(0, endTimeMs - startTimeMs);
+		const passed = this.testCases.filter((tc) => tc.status === "passed").length;
+		const failed = this.testCases.filter((tc) => tc.status === "failed").length;
+		const skipped = this.testCases.filter((tc) => tc.status === "skipped").length;
+		const timedOut = this.testCases.filter((tc) => tc.status === "timedOut").length;
+		const interrupted = this.testCases.filter((tc) => tc.status === "interrupted").length;
+		const numberOfProjects = this.config.projects.length;
+		const totalSequentialDuration = this.testCases.reduce((sum, tc) => sum + (tc.duration || 0), 0);
+		const summary = {
+			total: this.testCases.length,
+			passed,
+			failed,
+			skipped,
+			timedOut,
+			interrupted,
+			startTime: this.startTime,
+			endTime,
+			duration: wallClockDuration,
+			totalSequentialDuration,
+			numberOfProjects,
+			workers: this.config?.workers
+		};
+		const suites = this.buildSuites();
+		if (this.reportConfig.enableHistory !== false) this.writeRunHistory(summary, endTime);
+		const reportData = { testRun: {
+			summary,
+			suites,
+			projectName: this.reportConfig.projectName,
+			testRunName: this.reportConfig.testRunName,
+			theme: this.reportConfig.theme,
+			darkMode: this.reportConfig.darkMode,
+			enableHistory: this.reportConfig.enableHistory,
+			minimalReport: this.reportConfig.minimalReport
+		} };
+		const cwd = process.cwd();
+		const normalizedCwd = cwd.endsWith("/") ? cwd.slice(0, -1) : cwd;
+		const outputDir = path.resolve(normalizedCwd, this.reportConfig.outputDir);
+		fs.mkdirSync(outputDir, { recursive: true });
+		const jsonPath = path.join(outputDir, "report.json");
+		fs.writeFileSync(jsonPath, JSON.stringify(reportData, null, 2), "utf8");
+		if (this.progressMode === "dot") {
+			const failedCases = this.testCases.filter((tc) => tc.status === "failed" || tc.status === "timedOut" || tc.status === "interrupted");
+			if (failedCases.length > 0) {
+				console.log("\nFailed Tests:");
+				for (const tc of failedCases) {
+					const projStr = tc.project && tc.project !== "unknown" ? `[${tc.project}] ` : "";
+					const durationStr = tc.duration > 0 ? ` (${tc.duration}ms)` : "";
+					console.log(`❌ [FAILED] ${projStr}${tc.fileName} › ${tc.title}${durationStr}`);
+				}
+			}
+		}
+		const summaryTable = generateTerminalSummaryTable(summary, this.reportConfig.projectName, this.reportConfig.testRunName);
+		console.log("\n" + summaryTable);
+		try {
+			const pm = this.reportConfig.packageManager;
+			const moduleFile = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+			const moduleDir = path.dirname(moduleFile);
+			const packageRoot = moduleDir.endsWith(path.join("src", "lib")) || moduleDir.endsWith("src/lib") ? path.resolve(moduleDir, "..", "..") : path.resolve(moduleDir, "..");
+			const possibleTemplatePaths = [
+				path.join(packageRoot, "assets", "template.html"),
+				path.join(packageRoot, "dist", "index.html"),
+				path.join(packageRoot, "dist", "template.html")
+			];
+			let templateContent = null;
+			for (const p of possibleTemplatePaths) if (fs.existsSync(p)) try {
+				templateContent = fs.readFileSync(p, "utf8");
+				break;
+			} catch {}
+			if (!templateContent) {
+				const buildCmd = getViteBuildCommand(pm, packageRoot);
+				execSync(buildCmd, {
+					cwd: packageRoot,
+					stdio: "pipe",
+					env: {
+						...process.env,
+						PW_REPORTER_OUTPUT: outputDir
+					}
+				});
+				for (const p of possibleTemplatePaths) if (fs.existsSync(p)) try {
+					templateContent = fs.readFileSync(p, "utf8");
+					break;
+				} catch {}
+			}
+			if (templateContent) {
+				const dataScript = `<script id="report-data" type="application/json">${JSON.stringify(reportData).replace(/</g, "\\u003c")}<\/script>`;
+				const cleanTemplate = templateContent.replace(/<script id="report-data" type="application\/json">[\s\S]*?<\/script>/, "");
+				let finalHtml = cleanTemplate.replace("</head>", `${dataScript}\n</head>`);
+				const historyPath = path.join(outputDir, "history.json");
+				if (fs.existsSync(historyPath)) try {
+					const history = JSON.parse(fs.readFileSync(historyPath, "utf8"));
+					const historyScript = `<script id="history-data" type="application/json">${JSON.stringify(history).replace(/</g, "\\u003c")}<\/script>`;
+					finalHtml = finalHtml.replace(/<script id="history-data" type="application\/json">[\s\S]*?<\/script>/, "").replace("</head>", `${historyScript}\n</head>`);
+				} catch (e) {
+					console.error("History data injection failed:", e);
+				}
+				const destHtml = path.join(outputDir, "index.html");
+				fs.writeFileSync(destHtml, finalHtml, "utf8");
+				console.debug(`\n✓ Report generated: ${destHtml}`);
+				console.log(`\n💡 Run "${getShowReportCommand(pm)}" to view the report in web browser.\n`);
+				if (this.reportConfig.enableHistory !== false) this.refreshHistory();
+				if (this.reportConfig.singleSummaryFile) {
+					const summaryHtmlPath = path.join(outputDir, "summary.html");
+					const summaryHtml = cleanTemplate.replace("</head>", `${dataScript}\n<script>window.__ZEN_SUMMARY_ONLY__ = true;<\/script>\n</head>`);
+					fs.writeFileSync(summaryHtmlPath, summaryHtml, "utf8");
+					console.debug(`✓ Standalone Summary generated: ${summaryHtmlPath}`);
+				}
+			} else console.error("Report template not found and build failed.");
+		} catch (err) {
+			console.error("Report generation failed, keeping report.json:", err);
+		}
+	}
+};
+function getShowReportCommand(pm, cwd = process.cwd()) {
+	switch (pm || detectPackageManager(cwd)) {
+		case "pnpm": return "pnpm zr show";
+		case "yarn": return "yarn zr show";
+		case "bun": return "bunx zr show";
+		default: return "npx zr show";
+	}
+}
+//#endregion
+export { ZenReporter as default, getShowReportCommand, resolveConfig };