tryscript 0.1.2 → 0.1.4

package/README.md

@@ -1,7 +1,7 @@
 # tryscript
 
-[![CI](https://github.com/jlevy/tryscript/actions/workflows/ci.yml/badge.svg)](https://github.com/jlevy/tryscript/actions/workflows/ci.yml)
-[![Coverage](https://raw.githubusercontent.com/jlevy/tryscript/main/badges/packages/tryscript/coverage-total.svg)](https://raw.githubusercontent.com/jlevy/tryscript/main/badges/packages/tryscript/coverage-total.svg)
+[![CI](https://github.com/jlevy/tryscript/actions/workflows/ci.yml/badge.svg)](https://github.com/jlevy/tryscript/actions/runs/20828303484)
+[![Coverage](https://raw.githubusercontent.com/jlevy/tryscript/main/badges/packages/tryscript/coverage-total.svg)](https://github.com/jlevy/tryscript/actions/runs/20828303484)
 [![npm version](https://img.shields.io/npm/v/tryscript)](https://www.npmjs.com/package/tryscript)
 [![X Follow](https://img.shields.io/twitter/follow/ojoshe)](https://x.com/ojoshe)
 
@@ -22,25 +22,51 @@ Golden testing for CLI applications - a TypeScript port of [trycmd](https://gith
 Write CLI tests as Markdown. tryscript runs commands, captures output, and compares against expected results. Tests become documentation; documentation becomes tests.
 
 ````markdown
-# Test: Basic echo
+---
+env:
+  NO_COLOR: "1"
+sandbox: true
+---
+
+# Test: CLI help
 
 ```console
-$ echo "hello world"
-hello world
+$ my-cli --help
+Usage: my-cli [options] <command>
+
+Options:
+  --version  Show version
+  --help     Show this help
+...
 ? 0
 ```
 
-# Test: Grep with pattern matching
+# Test: Version output
 
 ```console
-$ ls -la | grep ".md"
-[..]README.md
-...
+$ my-cli --version
+my-cli v[..]
+? 0
+```
+
+# Test: Error handling
+
+```console
+$ my-cli unknown-command 2>&1
+Error: unknown command 'unknown-command'
+? 1
+```
+
+# Test: Check output file contents
+
+```console
+$ my-cli process data.json > output.txt && grep "success" output.txt
+[..]success[..]
 ? 0
 ```
 ````
 
-The `[..]` matches any text on that line. The `...` matches zero or more lines. These "elision patterns" let tests handle dynamic output gracefully.
+The `[..]` matches any text on that line. The `...` matches zero or more lines. These "elision patterns" let tests handle dynamic output gracefully. Any shell command works - pipes, redirects, environment variables, etc.
 
 ## Quick Start
 
@@ -68,46 +94,7 @@ npx tryscript run --update tests/
 - **Custom patterns** - Define regex patterns for timestamps, versions, UUIDs
 - **Update mode** - Regenerate expected output with `--update`
 - **Sandbox mode** - Isolate tests in temp directories
-- **Code coverage** - Track coverage from subprocess execution with `--coverage`
-
-## Example Test File
-
-````markdown
----
-env:
-  NO_COLOR: "1"
-sandbox: true
----
-
-# Test: CLI help
-
-```console
-$ my-cli --help
-Usage: my-cli [options] <command>
-
-Options:
-  --version  Show version
-  --help     Show this help
-...
-? 0
-```
-
-# Test: Version output
-
-```console
-$ my-cli --version
-my-cli v[..]
-? 0
-```
-
-# Test: Error handling
-
-```console
-$ my-cli unknown-command 2>&1
-Error: unknown command 'unknown-command'
-? 1
-```
-````
+- **Code coverage** - Track coverage from subprocess execution with `--coverage` (experimental; use `--coverage-monocart` for best accuracy)
 
 ## CLI Reference
 
@@ -134,6 +121,8 @@ For complete syntax reference, run `tryscript docs` or see the [reference docume
 | `--coverage-exclude-node-modules` | Exclude node_modules from coverage (default: true) |
 | `--coverage-exclude <pattern>` | Exclude patterns from coverage |
 
+> **Note**: Coverage features are experimental. See the [reference documentation](packages/tryscript/docs/tryscript-reference.md#code-coverage) for details on merged coverage, monocart integration, and sourcemap requirements.
+
 ## Development
 
 ```bash

package/dist/bin.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 
-const require_src = require('./src-BR3CZ3tc.cjs');
+const require_src = require('./src-BGWMAShO.cjs');
 let node_url = require("node:url");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -170,6 +170,237 @@ function buildUpdatedBlock(block, result) {
 	return lines.join("\n");
 }
 
+//#endregion
+//#region src/lib/lcov.ts
+/**
+* LCOV parsing, merging, and writing utilities.
+*
+* LCOV format reference:
+* - SF: Source file path
+* - DA:linenum,hitcount - Line data
+* - FN:linenum,funcname - Function definition
+* - FNDA:hitcount,funcname - Function hit data
+* - FNF: Functions found count
+* - FNH: Functions hit count
+* - BRF: Branches found count
+* - BRH: Branches hit count
+* - BRDA:line,block,branch,taken - Branch data
+* - LF: Lines found count
+* - LH: Lines hit count
+* - end_of_record - End of file record
+*/
+/**
+* Parse LCOV content into structured data.
+*/
+function parseLcov(content) {
+	const files = /* @__PURE__ */ new Map();
+	let currentFile = null;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("SF:")) {
+			const path = trimmed.slice(3);
+			currentFile = {
+				path,
+				lines: /* @__PURE__ */ new Map(),
+				functions: /* @__PURE__ */ new Map(),
+				branches: []
+			};
+			files.set(path, currentFile);
+		} else if (trimmed.startsWith("DA:") && currentFile) {
+			const parts = trimmed.slice(3).split(",");
+			const lineNumber = parseInt(parts[0], 10);
+			const hitCount = parseInt(parts[1], 10);
+			currentFile.lines.set(lineNumber, {
+				lineNumber,
+				hitCount
+			});
+		} else if (trimmed.startsWith("FN:") && currentFile) {
+			const parts = trimmed.slice(3).split(",");
+			const lineNumber = parseInt(parts[0], 10);
+			const name = parts.slice(1).join(",");
+			if (!currentFile.functions.has(name)) currentFile.functions.set(name, {
+				name,
+				lineNumber,
+				hitCount: 0
+			});
+			else currentFile.functions.get(name).lineNumber = lineNumber;
+		} else if (trimmed.startsWith("FNDA:") && currentFile) {
+			const parts = trimmed.slice(5).split(",");
+			const hitCount = parseInt(parts[0], 10);
+			const name = parts.slice(1).join(",");
+			if (currentFile.functions.has(name)) currentFile.functions.get(name).hitCount = hitCount;
+			else currentFile.functions.set(name, {
+				name,
+				lineNumber: 0,
+				hitCount
+			});
+		} else if (trimmed.startsWith("BRDA:") && currentFile) {
+			const parts = trimmed.slice(5).split(",");
+			currentFile.branches.push({
+				line: parseInt(parts[0], 10),
+				block: parseInt(parts[1], 10),
+				branch: parseInt(parts[2], 10),
+				taken: parts[3] === "-" ? -1 : parseInt(parts[3], 10)
+			});
+		} else if (trimmed === "end_of_record") currentFile = null;
+	}
+	return { files };
+}
+/**
+* Merge multiple LCOV data structures, taking max hit counts.
+*/
+function mergeLcov(...lcovs) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const lcov of lcovs) for (const [path, file] of lcov.files) if (!merged.has(path)) merged.set(path, {
+		path,
+		lines: new Map(file.lines),
+		functions: new Map(file.functions),
+		branches: [...file.branches]
+	});
+	else {
+		const existing = merged.get(path);
+		for (const [lineNum, lineData] of file.lines) {
+			const existingLine = existing.lines.get(lineNum);
+			if (existingLine) existingLine.hitCount = Math.max(existingLine.hitCount, lineData.hitCount);
+			else existing.lines.set(lineNum, { ...lineData });
+		}
+		for (const [name, funcData] of file.functions) {
+			const existingFunc = existing.functions.get(name);
+			if (existingFunc) existingFunc.hitCount = Math.max(existingFunc.hitCount, funcData.hitCount);
+			else existing.functions.set(name, { ...funcData });
+		}
+		for (const branch of file.branches) {
+			const existingBranch = existing.branches.find((b) => b.line === branch.line && b.block === branch.block && b.branch === branch.branch);
+			if (existingBranch) {
+				if (branch.taken >= 0) existingBranch.taken = existingBranch.taken >= 0 ? Math.max(existingBranch.taken, branch.taken) : branch.taken;
+			} else existing.branches.push({ ...branch });
+		}
+	}
+	return { files: merged };
+}
+/**
+* Convert LCOV data back to LCOV format string.
+*/
+function formatLcov(lcov) {
+	const lines = [];
+	for (const file of lcov.files.values()) {
+		lines.push(`SF:${file.path}`);
+		const sortedFunctions = [...file.functions.values()].sort((a, b) => a.lineNumber - b.lineNumber);
+		for (const func of sortedFunctions) lines.push(`FN:${func.lineNumber},${func.name}`);
+		for (const func of sortedFunctions) lines.push(`FNDA:${func.hitCount},${func.name}`);
+		const fnf = file.functions.size;
+		const fnh = [...file.functions.values()].filter((f) => f.hitCount > 0).length;
+		lines.push(`FNF:${fnf}`);
+		lines.push(`FNH:${fnh}`);
+		for (const branch of file.branches) {
+			const taken = branch.taken < 0 ? "-" : branch.taken.toString();
+			lines.push(`BRDA:${branch.line},${branch.block},${branch.branch},${taken}`);
+		}
+		const brf = file.branches.length;
+		const brh = file.branches.filter((b) => b.taken > 0).length;
+		lines.push(`BRF:${brf}`);
+		lines.push(`BRH:${brh}`);
+		const sortedLines = [...file.lines.values()].sort((a, b) => a.lineNumber - b.lineNumber);
+		for (const line of sortedLines) lines.push(`DA:${line.lineNumber},${line.hitCount}`);
+		const lf = file.lines.size;
+		const lh = [...file.lines.values()].filter((l) => l.hitCount > 0).length;
+		lines.push(`LF:${lf}`);
+		lines.push(`LH:${lh}`);
+		lines.push("end_of_record");
+	}
+	return lines.join("\n") + "\n";
+}
+/**
+* Convert LCOV data to JSON summary format (compatible with istanbul/vitest).
+*/
+function lcovToJsonSummary(lcov) {
+	const withPct = (total, covered) => ({
+		total,
+		covered,
+		skipped: 0,
+		pct: total > 0 ? parseFloat((covered / total * 100).toFixed(2)) : 100
+	});
+	const totals = {
+		lines: {
+			total: 0,
+			covered: 0
+		},
+		functions: {
+			total: 0,
+			covered: 0
+		},
+		branches: {
+			total: 0,
+			covered: 0
+		}
+	};
+	const summary = { total: {
+		lines: withPct(0, 0),
+		statements: withPct(0, 0),
+		functions: withPct(0, 0),
+		branches: withPct(0, 0),
+		branchesTrue: {
+			total: 0,
+			covered: 0,
+			skipped: 0,
+			pct: 100
+		}
+	} };
+	for (const file of lcov.files.values()) {
+		const linesTotal = file.lines.size;
+		const linesCovered = [...file.lines.values()].filter((l) => l.hitCount > 0).length;
+		const funcsTotal = file.functions.size;
+		const funcsCovered = [...file.functions.values()].filter((f) => f.hitCount > 0).length;
+		const branchesTotal = file.branches.length;
+		const branchesCovered = file.branches.filter((b) => b.taken > 0).length;
+		summary[file.path] = {
+			lines: withPct(linesTotal, linesCovered),
+			statements: withPct(linesTotal, linesCovered),
+			functions: withPct(funcsTotal, funcsCovered),
+			branches: withPct(branchesTotal, branchesCovered)
+		};
+		totals.lines.total += linesTotal;
+		totals.lines.covered += linesCovered;
+		totals.functions.total += funcsTotal;
+		totals.functions.covered += funcsCovered;
+		totals.branches.total += branchesTotal;
+		totals.branches.covered += branchesCovered;
+	}
+	summary.total = {
+		lines: withPct(totals.lines.total, totals.lines.covered),
+		statements: withPct(totals.lines.total, totals.lines.covered),
+		functions: withPct(totals.functions.total, totals.functions.covered),
+		branches: withPct(totals.branches.total, totals.branches.covered),
+		branchesTrue: {
+			total: 0,
+			covered: 0,
+			skipped: 0,
+			pct: 100
+		}
+	};
+	return summary;
+}
+/**
+* Read and parse an LCOV file.
+*/
+function readLcovFile(path) {
+	return parseLcov((0, node_fs.readFileSync)(path, "utf8"));
+}
+/**
+* Write LCOV data to a file.
+*/
+function writeLcovFile(path, lcov) {
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(path), { recursive: true });
+	(0, node_fs.writeFileSync)(path, formatLcov(lcov));
+}
+/**
+* Write JSON summary to a file.
+*/
+function writeJsonSummary(path, summary) {
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(path), { recursive: true });
+	(0, node_fs.writeFileSync)(path, JSON.stringify(summary, null, 2));
+}
+
 //#endregion
 //#region src/lib/coverage.ts
 /**
@@ -275,6 +506,33 @@ async function cleanupCoverageContext(ctx) {
 		});
 	} catch {}
 }
+/**
+* Merge external LCOV file with generated coverage.
+* Reads the generated lcov.info, merges with external LCOV, and writes back.
+* Also generates coverage-summary.json for badge generation.
+*
+* @returns Object with merged coverage percentages, or null if merge failed
+*/
+function mergeExternalCoverage(reportsDir, externalLcovPath) {
+	const generatedLcovPath = (0, node_path.join)(reportsDir, "lcov.info");
+	if (!(0, node_fs.existsSync)(externalLcovPath)) {
+		console.error(`External LCOV file not found: ${externalLcovPath}`);
+		return null;
+	}
+	if (!(0, node_fs.existsSync)(generatedLcovPath)) {
+		console.error(`Generated LCOV file not found: ${generatedLcovPath}`);
+		console.error("Make sure \"lcov\" is included in reporters");
+		return null;
+	}
+	const mergedLcov = mergeLcov(readLcovFile(externalLcovPath), readLcovFile(generatedLcovPath));
+	writeLcovFile(generatedLcovPath, mergedLcov);
+	const summary = lcovToJsonSummary(mergedLcov);
+	writeJsonSummary((0, node_path.join)(reportsDir, "coverage-summary.json"), summary);
+	return {
+		lines: summary.total.lines.pct,
+		functions: summary.total.functions.pct
+	};
+}
 
 //#endregion
 //#region src/cli/commands/run.ts
@@ -282,7 +540,7 @@ async function cleanupCoverageContext(ctx) {
 * Register the run command.
 */
 function registerRunCommand(program) {
-	program.command("run").description("Run golden tests").argument("[files...]", "Test files to run (default: **/*.tryscript.md)").option("--update", "Update golden files with actual output").option("--diff", "Show diff on failure (default: true)").option("--no-diff", "Hide diff on failure").option("--fail-fast", "Stop on first failure").option("--filter <pattern>", "Filter tests by name pattern").option("--verbose", "Show detailed output including passing test output").option("--quiet", "Suppress non-essential output (only show failures)").option("--coverage", "Enable code coverage collection (requires c8)").option("--coverage-dir <dir>", "Coverage output directory (default: coverage-tryscript)").option("--coverage-reporter <reporter...>", "Coverage reporters (default: text, html). Can be specified multiple times.").option("--coverage-exclude <pattern...>", "Patterns to exclude from coverage (c8 --exclude). Can be specified multiple times.").option("--coverage-exclude-node-modules", "Exclude node_modules from coverage (c8 --exclude-node-modules, default: true)").option("--no-coverage-exclude-node-modules", "Include node_modules in coverage (c8 --no-exclude-node-modules)").option("--coverage-exclude-after-remap", "Apply exclude logic after sourcemap remapping (c8 --exclude-after-remap)").option("--coverage-skip-full", "Hide files with 100% coverage (c8 --skip-full)").option("--coverage-allow-external", "Allow files from outside cwd (c8 --allowExternal)").option("--coverage-monocart", "Use monocart for accurate line counts, better for merging with vitest (c8 --experimental-monocart)").action(runCommand$1);
+	program.command("run").description("Run golden tests").argument("[files...]", "Test files to run (default: **/*.tryscript.md)").option("--update", "Update golden files with actual output").option("--diff", "Show diff on failure (default: true)").option("--no-diff", "Hide diff on failure").option("--fail-fast", "Stop on first failure").option("--filter <pattern>", "Filter tests by name pattern").option("--verbose", "Show detailed output including passing test output").option("--quiet", "Suppress non-essential output (only show failures)").option("--coverage", "Enable code coverage collection (requires c8)").option("--coverage-dir <dir>", "Coverage output directory (default: coverage-tryscript)").option("--coverage-reporter <reporter...>", "Coverage reporters (default: text, html). Can be specified multiple times.").option("--coverage-exclude <pattern...>", "Patterns to exclude from coverage (c8 --exclude). Can be specified multiple times.").option("--coverage-exclude-node-modules", "Exclude node_modules from coverage (c8 --exclude-node-modules, default: true)").option("--no-coverage-exclude-node-modules", "Include node_modules in coverage (c8 --no-exclude-node-modules)").option("--coverage-exclude-after-remap", "Apply exclude logic after sourcemap remapping (c8 --exclude-after-remap)").option("--coverage-skip-full", "Hide files with 100% coverage (c8 --skip-full)").option("--coverage-allow-external", "Allow files from outside cwd (c8 --allowExternal)").option("--coverage-monocart", "Use monocart for accurate line counts, better for merging with vitest (c8 --experimental-monocart)").option("--merge-lcov <path>", "Merge coverage from an existing LCOV file (e.g., from vitest --coverage)").action(runCommand$1);
 }
 async function runCommand$1(files, options) {
 	const startTime = Date.now();
@@ -311,16 +569,26 @@ async function runCommand$1(files, options) {
 			logError("Coverage requires c8. Install with: npm install -D c8");
 			process.exit(1);
 		}
+		let reporters = options.coverageReporter ?? globalConfig.coverage?.reporters;
+		if (options.mergeLcov) {
+			if (!reporters) reporters = [
+				"text",
+				"html",
+				"lcov"
+			];
+			else if (!reporters.includes("lcov")) reporters = [...reporters, "lcov"];
+		}
 		coverageCtx = await createCoverageContext({
 			...globalConfig.coverage,
 			reportsDir: options.coverageDir ?? globalConfig.coverage?.reportsDir,
-			reporters: options.coverageReporter ?? globalConfig.coverage?.reporters,
+			reporters,
 			exclude: options.coverageExclude ?? globalConfig.coverage?.exclude,
 			excludeNodeModules: options.coverageExcludeNodeModules ?? globalConfig.coverage?.excludeNodeModules,
 			excludeAfterRemap: options.coverageExcludeAfterRemap ?? globalConfig.coverage?.excludeAfterRemap,
 			skipFull: options.coverageSkipFull ?? globalConfig.coverage?.skipFull,
 			allowExternal: options.coverageAllowExternal ?? globalConfig.coverage?.allowExternal,
-			monocart: options.coverageMonocart ?? globalConfig.coverage?.monocart
+			monocart: options.coverageMonocart ?? globalConfig.coverage?.monocart,
+			mergeLcov: options.mergeLcov ?? globalConfig.coverage?.mergeLcov
 		});
 		coverageEnv = getCoverageEnv(coverageCtx);
 	}
@@ -394,6 +662,11 @@ async function runCommand$1(files, options) {
 		console.error("\nGenerating coverage report...");
 		try {
 			await generateCoverageReport(coverageCtx);
+			if (coverageCtx.options.mergeLcov) {
+				console.error(`Merging with external coverage: ${coverageCtx.options.mergeLcov}`);
+				const merged = mergeExternalCoverage(coverageCtx.options.reportsDir, coverageCtx.options.mergeLcov);
+				if (merged) console.error(colors.success(`Merged coverage: ${merged.lines}% lines, ${merged.functions}% functions`));
+			}
 			console.error(colors.success(`Coverage report written to ${coverageCtx.options.reportsDir}/`));
 		} catch (error) {
 			logError(`Failed to generate coverage report: ${error instanceof Error ? error.message : String(error)}`);
@@ -410,7 +683,7 @@ async function runCommand$1(files, options) {
 * Register the coverage command.
 */
 function registerCoverageCommand(program) {
-	program.command("coverage").description("Run commands with merged V8 coverage").argument("<commands...>", "Commands to run (each will inherit coverage environment)").option("--reports-dir <dir>", "Coverage output directory (default: coverage)").option("--reporters <reporters>", "Comma-separated coverage reporters (default: text,json,json-summary,lcov,html)").option("--include <patterns>", "Comma-separated patterns to include in coverage").option("--exclude <patterns>", "Comma-separated patterns to exclude from coverage").option("--exclude-node-modules", "Exclude node_modules from coverage (default: true)", true).option("--no-exclude-node-modules", "Include node_modules in coverage").option("--exclude-after-remap", "Apply exclude logic after sourcemap remapping").option("--skip-full", "Hide files with 100% coverage").option("--allow-external", "Allow files from outside cwd").option("--monocart", "Use monocart for accurate line counts (recommended for merging)").option("--src <dir>", "Source directory for sourcemap remapping (default: src)").action(coverageCommand);
+	program.command("coverage").description("Run commands with merged V8 coverage").argument("<commands...>", "Commands to run (each will inherit coverage environment)").option("--reports-dir <dir>", "Coverage output directory (default: coverage)").option("--reporters <reporters>", "Comma-separated coverage reporters (default: text,json,json-summary,lcov,html)").option("--include <patterns>", "Comma-separated patterns to include in coverage").option("--exclude <patterns>", "Comma-separated patterns to exclude from coverage").option("--exclude-node-modules", "Exclude node_modules from coverage (default: true)", true).option("--no-exclude-node-modules", "Include node_modules in coverage").option("--exclude-after-remap", "Apply exclude logic after sourcemap remapping").option("--skip-full", "Hide files with 100% coverage").option("--allow-external", "Allow files from outside cwd").option("--monocart", "Use monocart for accurate line counts (recommended for merging)").option("--src <dir>", "Source directory for sourcemap remapping (default: src)").option("--verbose", "Show coverage summary after each command for debugging").option("--merge-lcov <path>", "Merge coverage from an existing LCOV file (e.g., from vitest --coverage)").action(coverageCommand);
 }
 /**
 * Run a command with inherited coverage environment.
@@ -452,6 +725,74 @@ function findC8Path() {
 	return null;
 }
 /**
+* Get coverage file statistics from temp directory.
+*/
+async function getCoverageStats(tempDir) {
+	try {
+		const coverageFiles = (await (0, node_fs_promises.readdir)(tempDir)).filter((f) => f.startsWith("coverage-") && f.endsWith(".json"));
+		let totalBytes = 0;
+		for (const file of coverageFiles) {
+			const fileStat = await (0, node_fs_promises.stat)((0, node_path.join)(tempDir, file));
+			totalBytes += fileStat.size;
+		}
+		return {
+			fileCount: coverageFiles.length,
+			totalBytes,
+			files: coverageFiles
+		};
+	} catch {
+		return {
+			fileCount: 0,
+			totalBytes: 0,
+			files: []
+		};
+	}
+}
+/**
+* Generate a text-only coverage report for debugging (doesn't write files).
+*/
+async function generateTextReport(tempDir, options, label) {
+	const c8Path = findC8Path();
+	if (!c8Path) return;
+	const include = options.include ?? ["dist/**"];
+	const exclude = options.exclude ?? [];
+	const tempReportsDir = await (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "tryscript-coverage-report-"));
+	const reportArgs = [
+		"report",
+		"--temp-directory",
+		tempDir,
+		"--reports-dir",
+		tempReportsDir,
+		"--src",
+		options.src ?? "src",
+		"--all",
+		...include.flatMap((pattern) => ["--include", pattern]),
+		...exclude.flatMap((pattern) => ["--exclude", pattern]),
+		...options.excludeNodeModules !== false ? ["--exclude-node-modules"] : ["--no-exclude-node-modules"],
+		...options.excludeAfterRemap ? ["--exclude-after-remap"] : [],
+		...options.monocart ? ["--experimental-monocart"] : [],
+		"--reporter",
+		"text"
+	];
+	console.error(colors.info(`\n--- Coverage after: ${label} ---`));
+	await new Promise((resolve$2) => {
+		const proc = (0, node_child_process.spawn)(c8Path, reportArgs, {
+			stdio: "inherit",
+			shell: false
+		});
+		proc.on("close", () => {
+			resolve$2();
+		});
+		proc.on("error", () => {
+			resolve$2();
+		});
+	});
+	await (0, node_fs_promises.rm)(tempReportsDir, {
+		recursive: true,
+		force: true
+	});
+}
+/**
 * Generate c8 coverage report.
 */
 async function generateReport(tempDir, options) {
@@ -510,10 +851,17 @@ async function coverageCommand(commands, options) {
 		logError("Coverage requires c8. Install with: npm install -D c8");
 		process.exit(1);
 	}
+	const parsedOptions = {
+		...options,
+		reporters: options.reporters ? typeof options.reporters === "string" ? options.reporters.split(",") : options.reporters : void 0,
+		include: options.include ? typeof options.include === "string" ? options.include.split(",") : options.include : void 0,
+		exclude: options.exclude ? typeof options.exclude === "string" ? options.exclude.split(",") : options.exclude : void 0
+	};
 	const coverageTemp = await (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "tryscript-coverage-"));
 	const coverageEnv = { NODE_V8_COVERAGE: coverageTemp };
 	console.error(colors.info(`Collecting V8 coverage to ${coverageTemp}`));
 	let hasFailures = false;
+	let previousFileCount = 0;
 	try {
 		for (let i = 0; i < commands.length; i++) {
 			const command = commands[i];
@@ -523,19 +871,40 @@ async function coverageCommand(commands, options) {
 				logWarn(`Command exited with code ${result.code}: ${command}`);
 				hasFailures = true;
 			}
+			const stats = await getCoverageStats(coverageTemp);
+			const newFiles = stats.fileCount - previousFileCount;
+			const bytesKB = (stats.totalBytes / 1024).toFixed(1);
+			console.error(colors.info(`\nV8 coverage: ${stats.fileCount} files (${newFiles} new), ${bytesKB} KB total`));
+			if (newFiles === 0) logWarn("No new coverage files from this command. This may indicate the command doesn't write to NODE_V8_COVERAGE.");
+			if (parsedOptions.verbose && stats.fileCount > 0) await generateTextReport(coverageTemp, parsedOptions, command);
+			previousFileCount = stats.fileCount;
 		}
-		console.error(colors.info("\n=== Generating merged coverage report ==="));
-		const parsedOptions = {
-			...options,
-			reporters: options.reporters ? typeof options.reporters === "string" ? options.reporters.split(",") : options.reporters : void 0,
-			include: options.include ? typeof options.include === "string" ? options.include.split(",") : options.include : void 0,
-			exclude: options.exclude ? typeof options.exclude === "string" ? options.exclude.split(",") : options.exclude : void 0
-		};
+		console.error(colors.info("\n=== Generating coverage report ==="));
 		if (!await generateReport(coverageTemp, parsedOptions)) {
 			logError("Failed to generate coverage report");
 			process.exit(1);
 		}
-		console.error(colors.success(`\nCoverage report written to ${parsedOptions.reportsDir ?? "coverage"}/`));
+		const reportsDir = parsedOptions.reportsDir ?? "coverage";
+		if (parsedOptions.mergeLcov) {
+			const externalLcovPath = parsedOptions.mergeLcov;
+			const generatedLcovPath = (0, node_path.join)(reportsDir, "lcov.info");
+			if (!(0, node_fs.existsSync)(externalLcovPath)) {
+				logError(`External LCOV file not found: ${externalLcovPath}`);
+				process.exit(1);
+			}
+			if (!(0, node_fs.existsSync)(generatedLcovPath)) {
+				logError(`Generated LCOV file not found: ${generatedLcovPath}`);
+				logError("Make sure \"lcov\" is included in reporters");
+				process.exit(1);
+			}
+			console.error(colors.info(`\nMerging with external coverage: ${externalLcovPath}`));
+			const mergedLcov = mergeLcov(readLcovFile(externalLcovPath), readLcovFile(generatedLcovPath));
+			writeLcovFile(generatedLcovPath, mergedLcov);
+			const summary = lcovToJsonSummary(mergedLcov);
+			writeJsonSummary((0, node_path.join)(reportsDir, "coverage-summary.json"), summary);
+			console.error(colors.success(`\nMerged coverage: ${summary.total.lines.pct}% lines, ${summary.total.functions.pct}% functions`));
+		}
+		console.error(colors.success(`\nCoverage report written to ${reportsDir}/`));
 	} finally {
 		await (0, node_fs_promises.rm)(coverageTemp, {
 			recursive: true,