@c9up/helix 0.1.3

package/src/cli/coverage/aggregate.ts

@@ -0,0 +1,231 @@
+/**
+ * Aggregation: merge N raw coverage entries (possibly for the same file
+ * from different workers) into a single `CoverageSummary` with per-file
+ * and total line / function counts.
+ *
+ * Range merging strategy mirrors `v8-to-istanbul`:
+ *   - Walk ranges OUTERMOST-first so inner ranges OVERWRITE the outer
+ *     count for the lines they cover. A `count: 0` inner range carved
+ *     out of a `count: 5` outer correctly marks those inner lines as
+ *     uncovered, matching V8's block-coverage semantics. The previous
+ *     `Math.max` strategy hid uncovered branches behind their outer
+ *     function's hit count.
+ *   - V8 emits BYTE offsets (UTF-8); we convert via Buffer.byteLength
+ *     so non-ASCII source code maps lines correctly.
+ *   - When two workers cover the same file:
+ *       - if their `source` differs (cache-busting query loaded different
+ *         content), we keep the longer source (best-effort) but emit a
+ *         warning — offsets are only consistent within one source.
+ *       - functions are deduplicated by `(name, startOffset)` so the
+ *         lcov FNF count doesn't double.
+ */
+
+import type {
+	CoverageSummary,
+	FileSummary,
+	RawFileCoverage,
+	Totals,
+	V8Function,
+} from "./types.js";
+
+/**
+ * Build a function `byteOffset → 1-based line number` over `source`.
+ * V8 offsets are UTF-8 byte offsets, so we walk the string code-unit by
+ * code-unit and accumulate byte length to keep both indices in sync.
+ *
+ * Returns `[mapper, totalBytes]`. `totalBytes` is needed so callers can
+ * detect offsets pointing past EOF (corrupt input) and clamp.
+ */
+function buildOffsetToLine(
+	source: string,
+): [(offset: number) => number, number] {
+	const lineStarts: number[] = [0];
+	let byteIndex = 0;
+	for (let i = 0; i < source.length; i += 1) {
+		const code = source.charCodeAt(i);
+		// UTF-16 surrogate pair → encodes a single 4-byte UTF-8 char.
+		if (code >= 0xd800 && code <= 0xdbff && i + 1 < source.length) {
+			const next = source.charCodeAt(i + 1);
+			if (next >= 0xdc00 && next <= 0xdfff) {
+				byteIndex += 4;
+				i += 1;
+				continue;
+			}
+		}
+		// Lone surrogate or BMP char — Buffer.byteLength of one code unit:
+		//   < 0x80   → 1 byte
+		//   < 0x800  → 2 bytes
+		//   else     → 3 bytes (BMP non-surrogate)
+		if (code < 0x80) {
+			byteIndex += 1;
+			if (code === 10 /* \n */) lineStarts.push(byteIndex);
+		} else if (code < 0x800) {
+			byteIndex += 2;
+		} else {
+			byteIndex += 3;
+		}
+	}
+	const totalBytes = byteIndex;
+	const mapper = (offset: number): number => {
+		const clamped = Math.max(0, Math.min(offset, totalBytes));
+		// Binary search for the largest lineStart <= clamped.
+		let lo = 0;
+		let hi = lineStarts.length - 1;
+		while (lo < hi) {
+			const mid = (lo + hi + 1) >>> 1;
+			if (lineStarts[mid] <= clamped) lo = mid;
+			else hi = mid - 1;
+		}
+		return lo + 1;
+	};
+	return [mapper, totalBytes];
+}
+
+function computeFileSummary(entry: RawFileCoverage): FileSummary {
+	const [offsetToLine] = buildOffsetToLine(entry.source);
+	const lineHitsMap = new Map<number, number>();
+	const functionHits: FileSummary["functionHits"] = [];
+	let fnCovered = 0;
+	// Apply ranges across ALL functions in one global pass, sorted by
+	// span DESC. The whole-file pseudo-function (largest span) lands
+	// first; inner functions and their inner ranges overwrite — so a
+	// never-called inner function correctly drops its lines back to
+	// count=0 even though the script itself executed at count=1.
+	const allRanges: Array<{
+		startOffset: number;
+		endOffset: number;
+		count: number;
+	}> = [];
+	for (const fn of entry.functions) {
+		for (const r of fn.ranges) {
+			if (r.endOffset > r.startOffset) allRanges.push(r);
+		}
+	}
+	allRanges.sort((a, b) => {
+		const spanA = a.endOffset - a.startOffset;
+		const spanB = b.endOffset - b.startOffset;
+		if (spanA !== spanB) return spanB - spanA;
+		return a.startOffset - b.startOffset;
+	});
+	for (const r of allRanges) {
+		const startLine = offsetToLine(r.startOffset);
+		const endLine = offsetToLine(r.endOffset - 1);
+		for (let line = startLine; line <= endLine; line += 1) {
+			lineHitsMap.set(line, r.count);
+		}
+	}
+	for (const fn of entry.functions) {
+		const firstRange = fn.ranges[0];
+		// Skip pseudo-functions / synthetic entries with no usable range so
+		// reports don't carry `FN:0,name` (lcov rejects line < 1).
+		if (!firstRange) continue;
+		const fnCount = firstRange.count;
+		const fnLine = offsetToLine(firstRange.startOffset);
+		if (fnCount > 0) fnCovered += 1;
+		functionHits.push({
+			name: fn.functionName || "(anonymous)",
+			line: Math.max(1, fnLine),
+			count: fnCount,
+		});
+	}
+	const lineHits = Array.from(lineHitsMap.entries())
+		.map(([line, count]) => ({ line, count }))
+		.sort((a, b) => a.line - b.line);
+	const linesCovered = lineHits.filter((h) => h.count > 0).length;
+	const linesTotal = lineHits.length;
+	const fnTotal = functionHits.length;
+	return {
+		file: entry.file,
+		lines: { covered: linesCovered, total: linesTotal },
+		// Statements ≈ lines (V8 doesn't expose AST statement boundaries —
+		// matches Vitest's v8 provider).
+		statements: { covered: linesCovered, total: linesTotal },
+		functions: { covered: fnCovered, total: fnTotal },
+		// Branches deferred; report 0/0 so reporters / thresholds can still
+		// format the field consistently.
+		branches: { covered: 0, total: 0 },
+		lineHits,
+		functionHits,
+	};
+}
+
+/**
+ * Merge two raw entries for the same file. Functions are deduplicated by
+ * `(name, startOffset)` so concatenation doesn't double FNF in lcov.
+ * If `source` differs, we keep the longer one (best effort) and emit a
+ * stderr advisory — offsets only line up within one source.
+ */
+function mergeRaw(a: RawFileCoverage, b: RawFileCoverage): RawFileCoverage {
+	if (a.source && b.source && a.source !== b.source) {
+		process.stderr.write(
+			`helix-coverage: ${a.file} has divergent source content across workers — line attribution may be off\n`,
+		);
+	}
+	const seen = new Set<string>();
+	const merged: V8Function[] = [];
+	for (const fn of [...a.functions, ...b.functions]) {
+		const startOffset = fn.ranges[0]?.startOffset ?? -1;
+		const key = `${fn.functionName}@${startOffset}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		merged.push(fn);
+	}
+	return {
+		file: a.file,
+		source: a.source.length >= b.source.length ? a.source : b.source,
+		functions: merged,
+	};
+}
+
+function pct(covered: number, total: number): number {
+	if (total === 0) return 100;
+	return Math.round((covered / total) * 10000) / 100;
+}
+
+export function aggregate(raw: RawFileCoverage[]): CoverageSummary {
+	const byFile = new Map<string, RawFileCoverage>();
+	for (const entry of raw) {
+		// Skip files we couldn't read source for — emitting a 1-line ghost
+		// summary based on collapsed line=1 mapping is worse than omission.
+		if (!entry.source) {
+			process.stderr.write(
+				`helix-coverage: skipping ${entry.file} — source unreadable\n`,
+			);
+			continue;
+		}
+		const prev = byFile.get(entry.file);
+		byFile.set(entry.file, prev ? mergeRaw(prev, entry) : entry);
+	}
+	const files = Array.from(byFile.values())
+		.map(computeFileSummary)
+		// Files that ended up with 0 lines / 0 functions (no V8 data) are
+		// dropped — they distort per-file averages and clutter the table.
+		.filter((f) => f.lines.total > 0 || f.functions.total > 0)
+		.sort((a, b) => a.file.localeCompare(b.file));
+
+	const totals: Totals = {
+		lines: { covered: 0, total: 0, pct: 0 },
+		statements: { covered: 0, total: 0, pct: 0 },
+		functions: { covered: 0, total: 0, pct: 0 },
+		branches: { covered: 0, total: 0, pct: 0 },
+	};
+	for (const f of files) {
+		totals.lines.covered += f.lines.covered;
+		totals.lines.total += f.lines.total;
+		totals.statements.covered += f.statements.covered;
+		totals.statements.total += f.statements.total;
+		totals.functions.covered += f.functions.covered;
+		totals.functions.total += f.functions.total;
+		totals.branches.covered += f.branches.covered;
+		totals.branches.total += f.branches.total;
+	}
+	totals.lines.pct = pct(totals.lines.covered, totals.lines.total);
+	totals.statements.pct = pct(
+		totals.statements.covered,
+		totals.statements.total,
+	);
+	totals.functions.pct = pct(totals.functions.covered, totals.functions.total);
+	totals.branches.pct = pct(totals.branches.covered, totals.branches.total);
+
+	return { files, total: totals };
+}

package/src/cli/coverage/collect.ts

@@ -0,0 +1,63 @@
+/**
+ * Reads every `coverage-*.json` produced by the V8 profiler in a given
+ * directory, decodes `file://` URLs, and returns a normalised list of
+ * `RawFileCoverage` entries (one per unique script URL).
+ *
+ * Workers write coverage via `NODE_V8_COVERAGE=<dir>` — the orchestrator
+ * sets this env var on every spawn and reads the directory after all
+ * workers exit. Multiple workers may record the same file; we return ALL
+ * entries here and let `aggregate.ts` merge.
+ */
+
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { RawFileCoverage, V8CoverageFile } from "./types.js";
+
+export async function collect(dir: string): Promise<RawFileCoverage[]> {
+	let entries: string[];
+	try {
+		entries = await readdir(dir);
+	} catch {
+		return [];
+	}
+	const jsonFiles = entries.filter((e) => e.endsWith(".json"));
+	const all: RawFileCoverage[] = [];
+	for (const name of jsonFiles) {
+		const p = path.join(dir, name);
+		let parsed: V8CoverageFile;
+		try {
+			const raw = await readFile(p, "utf8");
+			parsed = JSON.parse(raw) as V8CoverageFile;
+		} catch {
+			continue;
+		}
+		for (const script of parsed.result ?? []) {
+			if (!script.url?.startsWith("file://")) continue;
+			// V8 sometimes appends `?query` params (our worker uses them as
+			// cache-busters) — strip them so the same file from two workers
+			// merges correctly.
+			const cleanUrl = script.url.split("?")[0];
+			let file: string;
+			try {
+				file = fileURLToPath(cleanUrl);
+			} catch {
+				continue;
+			}
+			let source = "";
+			try {
+				source = await readFile(file, "utf8");
+			} catch {
+				// Source read may fail for transient temp files or modules that
+				// have been GC'd — leave empty; downstream stages fall back to
+				// offset-only computation.
+			}
+			all.push({
+				file,
+				source,
+				functions: script.functions ?? [],
+			});
+		}
+	}
+	return all;
+}

package/src/cli/coverage/diff/base.ts

@@ -0,0 +1,46 @@
+/**
+ * Resolve the default base ref to diff against. Tries, in order:
+ *   1. `origin/main`
+ *   2. `origin/master`
+ *   3. local `main`
+ *   4. local `master`
+ *
+ * Returns `undefined` if none of those exist (so the caller can warn
+ * instead of failing the run). Throws when the `git` binary itself is
+ * missing — the caller distinguishes "no repo / no ref" (skip
+ * gracefully) from "git not installed" (configuration error).
+ */
+
+import { spawnSync } from "node:child_process";
+
+const CANDIDATES = ["origin/main", "origin/master", "main", "master"];
+
+export class GitMissingError extends Error {
+	constructor() {
+		super("git binary not found on PATH");
+		this.name = "GitMissingError";
+	}
+}
+
+function runGit(cwd: string, args: string[]): { ok: boolean } {
+	const result = spawnSync("git", args, {
+		cwd,
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+	const err = result.error as NodeJS.ErrnoException | undefined;
+	if (err?.code === "ENOENT") throw new GitMissingError();
+	return { ok: result.status === 0 };
+}
+
+function refExists(cwd: string, ref: string): boolean {
+	return runGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])
+		.ok;
+}
+
+export function resolveBaseRef(cwd: string): string | undefined {
+	if (!runGit(cwd, ["rev-parse", "--git-dir"]).ok) return undefined;
+	for (const cand of CANDIDATES) {
+		if (refExists(cwd, cand)) return cand;
+	}
+	return undefined;
+}

package/src/cli/coverage/diff/index.ts

@@ -0,0 +1,160 @@
+/**
+ * Diff-coverage facade — wires base resolution → git diff → parser →
+ * overlay → reporters → thresholds. Called by `run.ts` after the
+ * full-tree finalise.
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { enforce } from "../thresholds.js";
+import type {
+	CoverageSummary,
+	Thresholds,
+	ThresholdViolation,
+} from "../types.js";
+import { GitMissingError, resolveBaseRef } from "./base.js";
+import { overlay } from "./overlay.js";
+import { parseDiff } from "./parse.js";
+import { diffJson, diffTextSummary } from "./reporters.js";
+import type { DiffOptions, DiffSummary } from "./types.js";
+
+export type { DiffOptions, DiffSummary } from "./types.js";
+
+export interface DiffFinaliseInput extends DiffOptions {
+	root: string;
+	coverage: CoverageSummary;
+}
+
+export interface DiffFinaliseResult {
+	summary: DiffSummary;
+	violations: ThresholdViolation[];
+	textReport: string;
+	reportFiles: string[];
+	/** When `undefined`, the diff stage was skipped (not in a repo, no
+	 *  base ref, etc.) — callers should print `warning` and move on. */
+	warning?: string;
+}
+
+/**
+ * Wrap the diff totals into a `CoverageSummary`-shaped object so we can
+ * reuse the full-tree `enforce()` helper. Only `lines`/`statements` are
+ * populated; `functions`/`branches` are unsupported in diff mode and are
+ * rejected upfront in `validateDiffThresholds`.
+ */
+function toCoverageSummary(diff: DiffSummary): CoverageSummary {
+	return {
+		files: [],
+		total: {
+			lines: {
+				covered: diff.total.covered,
+				total: diff.total.added,
+				pct: diff.total.pct,
+			},
+			statements: {
+				covered: diff.total.covered,
+				total: diff.total.added,
+				pct: diff.total.pct,
+			},
+			functions: { covered: 0, total: 0, pct: 100 },
+			branches: { covered: 0, total: 0, pct: 100 },
+		},
+	};
+}
+
+function violationLine(
+	metric: keyof Thresholds,
+	actual: number,
+	threshold: number,
+): string {
+	return `coverage-diff: ${metric} ${actual.toFixed(1)} < threshold ${threshold}`;
+}
+
+/**
+ * Reject `functions`/`branches` thresholds in diff mode — we only track
+ * line-level diff coverage today, so silently passing those metrics
+ * would let users gate on metrics that always read 100%.
+ */
+function validateDiffThresholds(t: Thresholds | undefined): void {
+	if (!t) return;
+	const unsupported: string[] = [];
+	if (typeof t.functions === "number" && t.functions > 0)
+		unsupported.push("functions");
+	if (typeof t.branches === "number" && t.branches > 0)
+		unsupported.push("branches");
+	if (unsupported.length > 0) {
+		throw new Error(
+			`diff-cov thresholds: ${unsupported.join(", ")} are not supported (line-only). Drop those keys.`,
+		);
+	}
+}
+
+export async function finaliseDiff(
+	input: DiffFinaliseInput,
+): Promise<DiffFinaliseResult> {
+	validateDiffThresholds(input.thresholds);
+
+	const cwd = input.cwd ?? input.root;
+	let base: string | undefined;
+	try {
+		base = input.base ?? resolveBaseRef(cwd);
+	} catch (err) {
+		if (err instanceof GitMissingError) {
+			return {
+				summary: { files: [], total: { added: 0, covered: 0, pct: 100 } },
+				violations: [],
+				textReport: "",
+				reportFiles: [],
+				warning: "diff-cov: git binary not found on PATH. Skipping.",
+			};
+		}
+		throw err;
+	}
+	if (!base) {
+		return {
+			summary: { files: [], total: { added: 0, covered: 0, pct: 100 } },
+			violations: [],
+			textReport: "",
+			reportFiles: [],
+			warning:
+				"diff-cov: no git base ref resolved (origin/main, main, master). Skipping.",
+		};
+	}
+
+	let diffMap: ReturnType<typeof parseDiff>;
+	try {
+		diffMap = parseDiff({ cwd, base });
+	} catch (err) {
+		return {
+			summary: { files: [], total: { added: 0, covered: 0, pct: 100 } },
+			violations: [],
+			textReport: "",
+			reportFiles: [],
+			warning: `diff-cov: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+
+	const summary = overlay(input.coverage, diffMap);
+
+	const reportFiles: string[] = [];
+	const outputDir = input.outputDir ?? path.join(input.root, "coverage");
+	await mkdir(outputDir, { recursive: true });
+	const file = path.join(outputDir, "coverage-diff.json");
+	await writeFile(file, diffJson(summary, input.root), "utf8");
+	reportFiles.push(file);
+
+	const textReport = diffTextSummary(summary, input.root);
+
+	let violations: ThresholdViolation[] = [];
+	if (input.thresholds) {
+		violations = enforce(toCoverageSummary(summary), input.thresholds);
+	}
+
+	return { summary, violations, textReport, reportFiles };
+}
+
+/** Reformat threshold violations with the `coverage-diff:` prefix. */
+export function diffViolationSummary(violations: ThresholdViolation[]): string {
+	return violations
+		.map((v) => violationLine(v.metric, v.actual, v.threshold))
+		.join("\n");
+}

package/src/cli/coverage/diff/overlay.ts

@@ -0,0 +1,62 @@
+/**
+ * Overlay the diff map onto a `CoverageSummary` to compute per-file
+ * "added vs covered" totals.
+ *
+ * For each file in the diff:
+ *   - find the matching coverage entry by absolute path
+ *   - intersect the added line numbers with `lineHits` (count > 0 means
+ *     covered)
+ *   - emit a `DiffFileSummary`
+ *
+ * Files in the diff with no coverage entry are still reported (added
+ * lines, 0 covered) so a freshly-added module without any tests shows
+ * up red. Files in coverage but not in the diff are skipped (the PR
+ * didn't touch them, so they don't move the diff-coverage needle).
+ */
+
+import type { CoverageSummary } from "../types.js";
+import type { DiffFileSummary, DiffMap, DiffSummary } from "./types.js";
+
+function pct(covered: number, added: number): number {
+	if (added === 0) return 100;
+	return Math.round((covered / added) * 10000) / 100;
+}
+
+export function overlay(coverage: CoverageSummary, diff: DiffMap): DiffSummary {
+	const coverageByFile = new Map(coverage.files.map((f) => [f.file, f]));
+	const files: DiffFileSummary[] = [];
+	let totalAdded = 0;
+	let totalCovered = 0;
+
+	for (const [file, addedLines] of diff) {
+		if (addedLines.size === 0) continue;
+		const cov = coverageByFile.get(file);
+		const hitsByLine = cov
+			? new Map(cov.lineHits.map((h) => [h.line, h.count]))
+			: undefined;
+		const sortedAdded = [...addedLines].sort((a, b) => a - b);
+		const lineHits: DiffFileSummary["lineHits"] = sortedAdded.map((line) => {
+			const count = hitsByLine?.get(line);
+			return { line, covered: typeof count === "number" && count > 0 };
+		});
+		const covered = lineHits.filter((h) => h.covered).length;
+		files.push({
+			file,
+			added: addedLines.size,
+			covered,
+			lineHits,
+		});
+		totalAdded += addedLines.size;
+		totalCovered += covered;
+	}
+
+	files.sort((a, b) => a.file.localeCompare(b.file));
+	return {
+		files,
+		total: {
+			added: totalAdded,
+			covered: totalCovered,
+			pct: pct(totalCovered, totalAdded),
+		},
+	};
+}

package/src/cli/coverage/diff/parse.ts

@@ -0,0 +1,121 @@
+/**
+ * Parse `git diff --unified=0 --no-color <base>...HEAD` output into a
+ * `DiffMap`. Why three-dot: it computes the diff at the merge-base, so
+ * commits made on `base` AFTER our branch diverged are excluded. That's
+ * the "what this PR contributes" semantic users expect.
+ *
+ * We force `--src-prefix=a/ --dst-prefix=b/` and `core.quotepath=false`
+ * so the parser doesn't have to guess at user-side `diff.noprefix` or
+ * non-ASCII path quoting.
+ *
+ * Renames produce `+++ b/<new path>` so they're picked up at the new
+ * location. Deletes produce `+++ /dev/null` and are skipped. Binary
+ * files produce no `+` lines so they contribute nothing.
+ */
+
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import type { DiffMap } from "./types.js";
+
+const HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/;
+const FILE_HEADER_PLUS = /^\+\+\+ (?:b\/(.*)|\/dev\/null)$/;
+
+export interface ParseOptions {
+	cwd: string;
+	base: string;
+}
+
+function tryRealpath(p: string): string {
+	try {
+		return realpathSync(p);
+	} catch {
+		return p;
+	}
+}
+
+export function parseDiff(opts: ParseOptions): DiffMap {
+	const result = spawnSync(
+		"git",
+		[
+			"-c",
+			"core.quotepath=false",
+			"diff",
+			"--unified=0",
+			"--no-color",
+			"--src-prefix=a/",
+			"--dst-prefix=b/",
+			`${opts.base}...HEAD`,
+		],
+		{
+			cwd: opts.cwd,
+			encoding: "utf8",
+			maxBuffer: 64 * 1024 * 1024,
+		},
+	);
+	if (result.error) {
+		const err = result.error as NodeJS.ErrnoException;
+		if (err.code === "ENOENT") {
+			throw new Error("git binary not found on PATH");
+		}
+		if (err.code === "ENOBUFS") {
+			throw new Error(
+				"diff output exceeded 64 MB — branch is too divergent to overlay",
+			);
+		}
+		throw new Error(`git diff failed: ${err.message}`);
+	}
+	if (result.status !== 0) {
+		throw new Error(
+			`git diff exited ${result.status}: ${result.stderr?.trim() || "(no stderr — likely shallow clone or pruned ref)"}`,
+		);
+	}
+	return parseDiffString(result.stdout, opts.cwd);
+}
+
+/**
+ * Pure parser — exposed separately so tests can feed canned diff
+ * strings without spawning git. Keys are canonicalised via realpath so
+ * they line up with V8 coverage paths (which `filter.ts` realpaths).
+ */
+export function parseDiffString(diff: string, cwd: string): DiffMap {
+	const map: DiffMap = new Map();
+	let currentFile: string | undefined;
+	let nextAddedLine = 0;
+	const lines = diff.split(/\r?\n/);
+	for (const line of lines) {
+		const fileMatch = line.match(FILE_HEADER_PLUS);
+		if (fileMatch) {
+			const newPath = fileMatch[1];
+			if (!newPath) {
+				currentFile = undefined;
+				nextAddedLine = 0;
+				continue;
+			}
+			currentFile = tryRealpath(path.resolve(cwd, newPath));
+			nextAddedLine = 0;
+			continue;
+		}
+		if (!currentFile) continue;
+		const hunkMatch = line.match(HUNK_HEADER);
+		if (hunkMatch) {
+			nextAddedLine = Number.parseInt(hunkMatch[1], 10);
+			continue;
+		}
+		if (line.startsWith("+") && !line.startsWith("+++")) {
+			if (nextAddedLine < 1) {
+				// `+0,0` deletion-only hunks set nextAddedLine = 0; ignore stray
+				// `+` lines rather than emit invalid line numbers.
+				continue;
+			}
+			let set = map.get(currentFile);
+			if (!set) {
+				set = new Set();
+				map.set(currentFile, set);
+			}
+			set.add(nextAddedLine);
+			nextAddedLine += 1;
+		}
+	}
+	return map;
+}