coverage-check 0.1.0

package/src/github-comment.test.mts

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from "vitest";
+import { upsertComment, type GhRunner } from "./github-comment.mts";
+import { COMMENT_MARKER } from "./report.mts";
+
+function makeGh(responses: Record<string, string>): GhRunner & ReturnType<typeof vi.fn> {
+  const impl: GhRunner = (args) => {
+    const key = args.join(" ");
+    for (const [pattern, response] of Object.entries(responses)) {
+      if (key.includes(pattern)) return Promise.resolve(response);
+    }
+    return Promise.resolve("");
+  };
+  return vi.fn<typeof impl>(impl) as GhRunner & ReturnType<typeof vi.fn>;
+}
+
+const FAIL_BODY = `${COMMENT_MARKER}\n## failed`;
+const PASS_BODY = `${COMMENT_MARKER}\n## passed`;
+
+describe("upsertComment", () => {
+  it("posts a new comment on failure when none exists", async () => {
+    const gh = makeGh({ "issues/42/comments --paginate": "" });
+    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
+    const calls = gh.mock.calls.map((c) => c[0].join(" "));
+    expect(calls.some((c) => c.includes("issues/42/comments") && !c.includes("PATCH"))).toBe(true);
+  });
+
+  it("patches an existing comment on failure", async () => {
+    const gh = makeGh({ "issues/42/comments --paginate": "99\n" });
+    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
+    const calls = gh.mock.calls.map((c) => c[0].join(" "));
+    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
+  });
+
+  it("patches an existing failure comment to pass body", async () => {
+    const gh = makeGh({ "issues/42/comments --paginate": "99\n" });
+    await upsertComment(PASS_BODY, "owner/repo", 42, true, gh);
+    const calls = gh.mock.calls.map((c) => c[0].join(" "));
+    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
+  });
+
+  it("does nothing on pass when no prior comment exists", async () => {
+    const gh = makeGh({ "issues/42/comments --paginate": "" });
+    await upsertComment(PASS_BODY, "owner/repo", 42, true, gh);
+    expect(gh.mock.calls.length).toBe(1);
+  });
+
+  it("finds comment id when paginate produces null on first page then id on second", async () => {
+    const gh = makeGh({ "issues/42/comments --paginate": "\n99\n" });
+    await upsertComment(FAIL_BODY, "owner/repo", 42, false, gh);
+    const calls = gh.mock.calls.map((c) => c[0].join(" "));
+    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
+  });
+
+  it("falls back to POST and does not throw when comment lookup fails", async () => {
+    const lookupErrorGh = vi.fn<GhRunner>((args) =>
+      args.includes("--paginate") ? Promise.reject(new Error("API error")) : Promise.resolve(""),
+    );
+    await expect(
+      upsertComment(FAIL_BODY, "owner/repo", 42, false, lookupErrorGh),
+    ).resolves.toBeUndefined();
+    const calls = lookupErrorGh.mock.calls.map((c) => c[0].join(" "));
+    expect(calls.some((c) => c.includes("issues/42/comments") && !c.includes("PATCH"))).toBe(true);
+  });
+});

package/src/lcov-merge.mts

@@ -0,0 +1,34 @@
+import type { LcovData } from "./types.mts";
+
+/** Merges multiple LcovData maps by summing hit counts per file per line. */
+export function mergeLcov(reports: LcovData[]): LcovData {
+  const merged: LcovData = new Map();
+
+  for (const report of reports) {
+    for (const [file, lines] of report) {
+      let target = merged.get(file);
+      if (target === undefined) {
+        target = new Map();
+        merged.set(file, target);
+      }
+      for (const [lineNo, hits] of lines) {
+        target.set(lineNo, (target.get(lineNo) ?? 0) + hits);
+      }
+    }
+  }
+
+  return merged;
+}
+
+/** Serializes LcovData back to LCOV text format. */
+export function toLcov(lcov: LcovData): string {
+  const lines: string[] = [];
+  for (const [file, fileLines] of lcov) {
+    lines.push(`SF:${file}`);
+    for (const [lineNo, hits] of fileLines) {
+      lines.push(`DA:${lineNo},${hits}`);
+    }
+    lines.push("end_of_record");
+  }
+  return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+}

package/src/lcov-merge.test.mts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { parseLcov } from "./lcov-parser.mts";
+import { mergeLcov, toLcov } from "./lcov-merge.mts";
+
+describe("mergeLcov", () => {
+  it("merges two reports by summing hit counts", () => {
+    const a = parseLcov(`SF:web/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n`);
+    const b = parseLcov(`SF:web/foo.mts\nDA:1,2\nDA:3,1\nend_of_record\n`);
+    const merged = mergeLcov([a, b]);
+    const lines = merged.get("web/foo.mts")!;
+    expect(lines.get(1)).toBe(3);
+    expect(lines.get(2)).toBe(0);
+    expect(lines.get(3)).toBe(1);
+  });
+
+  it("includes files present in only one report", () => {
+    const a = parseLcov(`SF:backend/a.mts\nDA:1,1\nend_of_record\n`);
+    const b = parseLcov(`SF:backend/b.mts\nDA:2,1\nend_of_record\n`);
+    const merged = mergeLcov([a, b]);
+    expect(merged.has("backend/a.mts")).toBe(true);
+    expect(merged.has("backend/b.mts")).toBe(true);
+  });
+
+  it("handles a shard that did not execute a given file", () => {
+    const a = parseLcov(`SF:backend/service.mts\nDA:10,1\nend_of_record\n`);
+    const b = parseLcov(`SF:backend/other.mts\nDA:1,1\nend_of_record\n`);
+    const merged = mergeLcov([a, b]);
+    expect(merged.get("backend/service.mts")?.get(10)).toBe(1);
+  });
+
+  it("returns empty map for empty input", () => {
+    expect(mergeLcov([])).toEqual(new Map());
+  });
+});
+
+describe("toLcov", () => {
+  it("serializes an empty map to an empty string", () => {
+    expect(toLcov(new Map())).toBe("");
+  });
+
+  it("round-trips through parseLcov", () => {
+    const original = parseLcov(`SF:backend/foo.mts\nDA:1,2\nDA:3,0\nend_of_record\n`);
+    const text = toLcov(original);
+    const roundTripped = parseLcov(text);
+    expect(roundTripped.get("backend/foo.mts")?.get(1)).toBe(2);
+    expect(roundTripped.get("backend/foo.mts")?.get(3)).toBe(0);
+  });
+
+  it("serializes multiple files", () => {
+    const data = parseLcov(`SF:a.mts\nDA:1,1\nend_of_record\nSF:b.mts\nDA:2,3\nend_of_record\n`);
+    const text = toLcov(data);
+    expect(text).toContain("SF:a.mts");
+    expect(text).toContain("SF:b.mts");
+    expect(text).toContain("DA:1,1");
+    expect(text).toContain("DA:2,3");
+  });
+});

package/src/lcov-parser.mts

@@ -0,0 +1,46 @@
+import type { LcovData } from "./types.mts";
+
+/**
+ * Parses LCOV text into a map of repo-root-relative file path → line → hit count.
+ *
+ * Paths are normalized by stripping a given prefix (e.g. $GITHUB_WORKSPACE or cwd)
+ * so callers see repo-root-relative paths regardless of where the runner ran.
+ */
+export function parseLcov(text: string, stripPrefixes: string[] = []): LcovData {
+  const result: LcovData = new Map();
+  let currentLines: Map<number, number> | null = null;
+
+  for (const raw of text.split("\n")) {
+    const line = raw.trimEnd();
+
+    if (line.startsWith("SF:")) {
+      let path = line.slice(3);
+      for (const prefix of stripPrefixes) {
+        if (path.startsWith(prefix)) {
+          path = path.slice(prefix.length);
+          break;
+        }
+      }
+      path = normalizePath(path);
+      currentLines = result.get(path) ?? new Map();
+      result.set(path, currentLines);
+    } else if (line.startsWith("DA:") && currentLines !== null) {
+      const rest = line.slice(3);
+      const comma = rest.indexOf(",");
+      if (comma === -1) continue;
+      const lineNo = parseInt(rest.slice(0, comma), 10);
+      const hits = parseInt(rest.slice(comma + 1), 10);
+      if (!Number.isFinite(lineNo) || !Number.isFinite(hits)) continue;
+      const prev = currentLines.get(lineNo) ?? 0;
+      currentLines.set(lineNo, prev + hits);
+    } else if (line === "end_of_record") {
+      currentLines = null;
+    }
+  }
+
+  return result;
+}
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}

package/src/lcov-parser.test.mts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { parseLcov } from "./lcov-parser.mts";
+
+const SIMPLE_LCOV = `
+SF:web/components/Foo.tsx
+DA:1,1
+DA:2,0
+DA:3,1
+end_of_record
+SF:web/components/Bar.tsx
+DA:10,2
+end_of_record
+`;
+
+const ABSOLUTE_LCOV = `
+SF:/home/runner/work/repo/repo/web/lib/api/client.mts
+DA:5,1
+DA:6,0
+end_of_record
+`;
+
+const WINDOWS_LCOV = `
+SF:.\\backend\\services\\foo.mts
+DA:1,1
+end_of_record
+`;
+
+describe("parseLcov", () => {
+  it("parses basic SF and DA records", () => {
+    const result = parseLcov(SIMPLE_LCOV);
+    expect(result.get("web/components/Foo.tsx")?.get(1)).toBe(1);
+    expect(result.get("web/components/Foo.tsx")?.get(2)).toBe(0);
+    expect(result.get("web/components/Bar.tsx")?.get(10)).toBe(2);
+  });
+
+  it("strips provided prefix from absolute paths", () => {
+    const result = parseLcov(ABSOLUTE_LCOV, ["/home/runner/work/repo/repo/"]);
+    expect(result.has("web/lib/api/client.mts")).toBe(true);
+    expect(result.get("web/lib/api/client.mts")?.get(5)).toBe(1);
+  });
+
+  it("normalizes Windows backslash separators", () => {
+    const result = parseLcov(WINDOWS_LCOV);
+    expect(result.has("backend/services/foo.mts")).toBe(true);
+  });
+
+  it("strips leading ./ from SF paths", () => {
+    const lcov = `SF:./web/components/Baz.tsx\nDA:1,1\nend_of_record\n`;
+    const result = parseLcov(lcov);
+    expect(result.has("web/components/Baz.tsx")).toBe(true);
+  });
+
+  it("handles missing end_of_record gracefully", () => {
+    const lcov = `SF:web/foo.mts\nDA:1,1\n`;
+    const result = parseLcov(lcov);
+    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
+  });
+
+  it("sums hits when the same file appears multiple times (shard merge)", () => {
+    const lcov = `
+SF:web/components/Foo.tsx
+DA:1,2
+end_of_record
+SF:web/components/Foo.tsx
+DA:1,3
+DA:2,1
+end_of_record
+`;
+    const result = parseLcov(lcov);
+    expect(result.get("web/components/Foo.tsx")?.get(1)).toBe(5);
+    expect(result.get("web/components/Foo.tsx")?.get(2)).toBe(1);
+  });
+
+  it("skips DA lines with malformed content (no comma)", () => {
+    const lcov = `SF:web/foo.mts\nDA:badline\nDA:1,1\nend_of_record\n`;
+    const result = parseLcov(lcov);
+    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
+    expect(result.get("web/foo.mts")?.size).toBe(1);
+  });
+
+  it("skips DA lines with non-finite values", () => {
+    const lcov = `SF:web/foo.mts\nDA:NaN,1\nDA:1,1\nend_of_record\n`;
+    const result = parseLcov(lcov);
+    expect(result.get("web/foo.mts")?.get(1)).toBe(1);
+  });
+});

package/src/load-artifacts.mts

@@ -0,0 +1,42 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+
+/** Recursively collects all lcov.info files under the given directory. */
+export function collectLcovFiles(dir: string): string[] {
+  const results: string[] = [];
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...collectLcovFiles(full));
+      } else if (entry.name === "lcov.info") {
+        results.push(full);
+      }
+    }
+  } catch (err) {
+    /* c8 ignore next */
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT")
+      /* c8 ignore next */
+      process.stderr.write(
+        `coverage-check: unexpected error reading artifacts directory ${dir}: ${err}\n`,
+      );
+    // ENOENT: directory does not exist — no artifacts
+  }
+  return results;
+}
+
+/**
+ * Builds the list of path prefixes to strip from LCOV SF: lines.
+ *
+ * Defaults: $GITHUB_WORKSPACE (if set) and cwd are always prepended.
+ * Additional prefixes can be passed via the `extra` parameter.
+ */
+export function buildStripPrefixes(extra: string[] = []): string[] {
+  const prefixes: string[] = extra.map((p) => (p.endsWith("/") ? p : `${p}/`));
+  const ws = process.env["GITHUB_WORKSPACE"];
+  if (ws) prefixes.push(ws.endsWith("/") ? ws : `${ws}/`);
+  const cwd = process.cwd();
+  /* c8 ignore next -- process.cwd() virtually never returns a trailing-slash path */
+  prefixes.push(cwd.endsWith("/") ? cwd : `${cwd}/`);
+  return prefixes;
+}

package/src/load-artifacts.test.mts

@@ -0,0 +1,115 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { collectLcovFiles, buildStripPrefixes } from "./load-artifacts.mts";
+
+describe("collectLcovFiles", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "load-artifacts-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns empty array for missing directory (ENOENT silenced)", () => {
+    expect(collectLcovFiles(join(tmpDir, "nonexistent"))).toEqual([]);
+  });
+
+  it("returns empty array for empty directory", () => {
+    expect(collectLcovFiles(tmpDir)).toEqual([]);
+  });
+
+  it("finds lcov.info at the top level", () => {
+    writeFileSync(join(tmpDir, "lcov.info"), "");
+    const results = collectLcovFiles(tmpDir);
+    expect(results).toHaveLength(1);
+    expect(results[0]).toContain("lcov.info");
+  });
+
+  it("ignores non-lcov.info files", () => {
+    writeFileSync(join(tmpDir, "coverage.json"), "");
+    writeFileSync(join(tmpDir, "lcov.txt"), "");
+    expect(collectLcovFiles(tmpDir)).toHaveLength(0);
+  });
+
+  it("recursively finds lcov.info in subdirectories", () => {
+    const sub1 = join(tmpDir, "backend");
+    const sub2 = join(tmpDir, "backend", "nested");
+    mkdirSync(sub2, { recursive: true });
+    writeFileSync(join(sub1, "lcov.info"), "");
+    writeFileSync(join(sub2, "lcov.info"), "");
+    const results = collectLcovFiles(tmpDir);
+    expect(results).toHaveLength(2);
+  });
+
+  it("finds lcov.info in multiple sibling subdirectories", () => {
+    mkdirSync(join(tmpDir, "backend"));
+    mkdirSync(join(tmpDir, "frontend"));
+    writeFileSync(join(tmpDir, "backend", "lcov.info"), "");
+    writeFileSync(join(tmpDir, "frontend", "lcov.info"), "");
+    expect(collectLcovFiles(tmpDir)).toHaveLength(2);
+  });
+});
+
+describe("buildStripPrefixes", () => {
+  it("always includes cwd as a suffix-slash prefix", () => {
+    const prefixes = buildStripPrefixes();
+    const cwd = process.cwd();
+    const expected = cwd.endsWith("/") ? cwd : `${cwd}/`;
+    expect(prefixes).toContain(expected);
+  });
+
+  it("includes GITHUB_WORKSPACE when set", () => {
+    const origWs = process.env["GITHUB_WORKSPACE"];
+    process.env["GITHUB_WORKSPACE"] = "/home/runner/work/repo";
+    try {
+      const prefixes = buildStripPrefixes();
+      expect(prefixes.some((p) => p.startsWith("/home/runner/work/repo"))).toBe(true);
+    } finally {
+      if (origWs === undefined) {
+        delete process.env["GITHUB_WORKSPACE"];
+      } else {
+        process.env["GITHUB_WORKSPACE"] = origWs;
+      }
+    }
+  });
+
+  it("does not include github workspace prefix when env var is absent", () => {
+    const origWs = process.env["GITHUB_WORKSPACE"];
+    delete process.env["GITHUB_WORKSPACE"];
+    try {
+      const prefixes = buildStripPrefixes();
+      // Only cwd and extra prefixes should be present
+      expect(prefixes).toHaveLength(1);
+    } finally {
+      if (origWs !== undefined) {
+        process.env["GITHUB_WORKSPACE"] = origWs;
+      }
+    }
+  });
+
+  it("normalizes extra prefixes to end with /", () => {
+    const prefixes = buildStripPrefixes(["/some/path", "/other/path/"]);
+    expect(prefixes[0]).toBe("/some/path/");
+    expect(prefixes[1]).toBe("/other/path/");
+  });
+
+  it("includes GITHUB_WORKSPACE with trailing slash when it already ends with /", () => {
+    const origWs = process.env["GITHUB_WORKSPACE"];
+    process.env["GITHUB_WORKSPACE"] = "/home/runner/work/repo/";
+    try {
+      const prefixes = buildStripPrefixes();
+      expect(prefixes.some((p) => p === "/home/runner/work/repo/")).toBe(true);
+    } finally {
+      if (origWs === undefined) {
+        delete process.env["GITHUB_WORKSPACE"];
+      } else {
+        process.env["GITHUB_WORKSPACE"] = origWs;
+      }
+    }
+  });
+});

package/src/patch-coverage.mts

@@ -0,0 +1,82 @@
+import type {
+  BucketResult,
+  CoverageRule,
+  DiffLines,
+  FileCoverageResult,
+  LcovData,
+} from "./types.mts";
+import { matchRule } from "./rules.mts";
+
+export function computePatchCoverage(
+  diff: DiffLines,
+  lcov: LcovData,
+  rules: CoverageRule[],
+): { buckets: BucketResult[]; informational: FileCoverageResult[] } {
+  const bucketMap = new Map<string, BucketResult>();
+  const informational: FileCoverageResult[] = [];
+
+  for (const [file, changedLineSet] of diff) {
+    const fileLines = lcov.get(file);
+    if (fileLines === undefined) continue; // not in lcov scope — skip
+
+    const coverable: number[] = [];
+    const uncoveredLines: number[] = [];
+    let hit = 0;
+
+    for (const lineNo of changedLineSet) {
+      if (!fileLines.has(lineNo)) continue; // line not tracked by coverage
+      coverable.push(lineNo);
+      if (fileLines.get(lineNo)! > 0) {
+        hit++;
+      } else {
+        uncoveredLines.push(lineNo);
+      }
+    }
+
+    if (coverable.length === 0) continue;
+
+    const rule = matchRule(file, rules);
+    const fileResult: FileCoverageResult = {
+      file,
+      coverable: coverable.length,
+      hit,
+      uncoveredLines: uncoveredLines.sort((a, b) => a - b),
+      rule: rule?.paths ?? null,
+    };
+
+    if (rule === null) {
+      informational.push(fileResult);
+      continue;
+    }
+
+    let bucket = bucketMap.get(rule.paths);
+    if (bucket === undefined) {
+      bucket = {
+        rule: rule.paths,
+        threshold: rule.patch_coverage_min,
+        coverable: 0,
+        hit: 0,
+        files: [],
+        passed: true,
+      };
+      bucketMap.set(rule.paths, bucket);
+    }
+
+    bucket.coverable += coverable.length;
+    bucket.hit += hit;
+    bucket.files.push(fileResult);
+  }
+
+  const buckets = [...bucketMap.values()];
+  for (const bucket of buckets) {
+    /* c8 ignore next -- bucket always has coverable>0 (L36 guard prevents empty-coverable files from reaching bucketMap) */
+    if (bucket.coverable === 0) {
+      bucket.passed = true;
+    } else {
+      const pct = (bucket.hit / bucket.coverable) * 100;
+      bucket.passed = pct >= bucket.threshold;
+    }
+  }
+
+  return { buckets, informational };
+}

package/src/patch-coverage.test.mts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { parseLcov } from "./lcov-parser.mts";
+import { parseDiff } from "./diff-parser.mts";
+import { computePatchCoverage } from "./patch-coverage.mts";
+import type { CoverageRule } from "./types.mts";
+
+const rules: CoverageRule[] = [
+  { paths: "backend/**", patch_coverage_min: 90 },
+  { paths: "web/**", patch_coverage_min: 5 },
+];
+
+describe("computePatchCoverage", () => {
+  it("passes when all changed lines are covered", () => {
+    const lcov = parseLcov(`SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n`);
+    const diff: ReturnType<typeof parseDiff> = new Map([["backend/foo.mts", new Set([1, 2])]]);
+    const { buckets } = computePatchCoverage(diff, lcov, rules);
+    const bucket = buckets.find((b) => b.rule === "backend/**")!;
+    expect(bucket.passed).toBe(true);
+    expect(bucket.hit).toBe(2);
+    expect(bucket.coverable).toBe(2);
+  });
+
+  it("fails when coverage drops below threshold", () => {
+    const lcov = parseLcov(
+      `SF:backend/foo.mts\nDA:1,1\nDA:2,1\nDA:3,1\nDA:4,1\nDA:5,1\nDA:6,1\nDA:7,1\nDA:8,1\nDA:9,0\nDA:10,0\nend_of_record\n`,
+    );
+    const diff: ReturnType<typeof parseDiff> = new Map([
+      ["backend/foo.mts", new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])],
+    ]);
+    const { buckets } = computePatchCoverage(diff, lcov, rules);
+    const bucket = buckets.find((b) => b.rule === "backend/**")!;
+    expect(bucket.passed).toBe(false);
+    expect(bucket.hit).toBe(8);
+    expect(bucket.coverable).toBe(10);
+  });
+
+  it("passes vacuously when no coverable changed lines", () => {
+    const lcov = parseLcov(`SF:backend/foo.mts\nDA:1,1\nend_of_record\n`);
+    const diff: ReturnType<typeof parseDiff> = new Map([["backend/foo.mts", new Set([99])]]);
+    const { buckets } = computePatchCoverage(diff, lcov, rules);
+    const bucket = buckets.find((b) => b.rule === "backend/**");
+    expect(!bucket || bucket.passed).toBe(true);
+  });
+
+  it("skips files not in lcov", () => {
+    const lcov = parseLcov(`SF:backend/other.mts\nDA:1,1\nend_of_record\n`);
+    const diff: ReturnType<typeof parseDiff> = new Map([
+      ["backend/missing.mts", new Set([1, 2, 3])],
+    ]);
+    const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
+    expect(buckets).toHaveLength(0);
+    expect(informational).toHaveLength(0);
+  });
+
+  it("routes unmatched files to informational", () => {
+    const lcov = parseLcov(`SF:scripts/ci.mts\nDA:1,0\nend_of_record\n`);
+    const diff: ReturnType<typeof parseDiff> = new Map([["scripts/ci.mts", new Set([1])]]);
+    const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
+    expect(buckets).toHaveLength(0);
+    expect(informational).toHaveLength(1);
+    expect(informational[0]?.file).toBe("scripts/ci.mts");
+  });
+
+  it("accumulates multiple files into the same bucket", () => {
+    // Two backend files → both go into the 'backend/**' bucket
+    const lcov = parseLcov(
+      `SF:backend/a.mts\nDA:1,1\nDA:2,1\nend_of_record\nSF:backend/b.mts\nDA:10,0\nDA:11,0\nend_of_record\n`,
+    );
+    const diff: ReturnType<typeof parseDiff> = new Map([
+      ["backend/a.mts", new Set([1, 2])],
+      ["backend/b.mts", new Set([10, 11])],
+    ]);
+    const { buckets } = computePatchCoverage(diff, lcov, rules);
+    const bucket = buckets.find((b) => b.rule === "backend/**")!;
+    expect(bucket.coverable).toBe(4);
+    expect(bucket.hit).toBe(2);
+    expect(bucket.files).toHaveLength(2);
+  });
+
+  it("reports uncovered lines correctly", () => {
+    const lcov = parseLcov(
+      `SF:backend/svc.mts\nDA:10,1\nDA:11,0\nDA:12,0\nDA:13,1\nend_of_record\n`,
+    );
+    const diff: ReturnType<typeof parseDiff> = new Map([
+      ["backend/svc.mts", new Set([10, 11, 12, 13])],
+    ]);
+    const { buckets } = computePatchCoverage(diff, lcov, rules);
+    const file = buckets[0]?.files[0]!;
+    expect(file.uncoveredLines).toEqual([11, 12]);
+  });
+});