coverage-check 0.2.1 → 0.2.2

package/dist/src/github-comment.mjs

@@ -0,0 +1,66 @@
+import { COMMENT_MARKER } from "./report.mjs";
+/* c8 ignore start */
+async function defaultGhRunner(args) {
+    const { spawn } = await import("node:child_process");
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const proc = spawn("gh", args, { stdio: ["ignore", "pipe", "inherit"] });
+        proc.stdout.on("data", (chunk) => chunks.push(chunk));
+        proc.on("error", reject);
+        proc.on("close", (code) => code === 0
+            ? resolve(Buffer.concat(chunks).toString("utf8"))
+            : reject(new Error(`gh ${args[0]} exited with code ${code}`)));
+    });
+}
+/* c8 ignore stop */
+/** Finds the ID of the existing coverage-check sticky comment, if any. */
+async function findExistingComment(repo, pr, gh) {
+    try {
+        const raw = await gh([
+            "api",
+            `repos/${repo}/issues/${pr}/comments`,
+            "--paginate",
+            "-q",
+            `first(.[] | select(.body | startswith("${COMMENT_MARKER}"))) | .id`,
+        ]);
+        // --paginate applies the jq filter per page; take the first valid ID across all lines
+        const id = raw
+            .split("\n")
+            .map((line) => parseInt(line.trim(), 10))
+            .find((n) => Number.isFinite(n) && n > 0);
+        return id ?? null;
+    }
+    catch (err) {
+        process.stderr.write(`coverage-check: warning: failed to look up existing comment: ${err}\n`);
+        return null;
+    }
+}
+/**
+ * Posts or updates the sticky coverage-check comment on a pull request.
+ *
+ * - On failure: upserts the failure comment body (POST if absent, PATCH if exists).
+ * - On pass with prior comment: deletes the prior comment.
+ * - On pass with no prior comment: stays silent.
+ */
+export async function upsertComment(body, repo, pr, passed, gh = defaultGhRunner) {
+    const existingId = await findExistingComment(repo, pr, gh);
+    if (passed && existingId === null)
+        return;
+    if (passed && existingId !== null) {
+        await gh(["api", `repos/${repo}/issues/comments/${existingId}`, "-X", "DELETE"]);
+        return;
+    }
+    if (existingId !== null) {
+        await gh([
+            "api",
+            `repos/${repo}/issues/comments/${existingId}`,
+            "-X",
+            "PATCH",
+            "-f",
+            `body=${body}`,
+        ]);
+    }
+    else {
+        await gh(["api", `repos/${repo}/issues/${pr}/comments`, "-f", `body=${body}`]);
+    }
+}

package/dist/src/lcov-merge.d.mts

@@ -0,0 +1,5 @@
+import type { LcovData } from "./types.mts";
+/** Merges multiple LcovData maps by summing hit counts per file per line. */
+export declare function mergeLcov(reports: LcovData[]): LcovData;
+/** Serializes LcovData back to LCOV text format. */
+export declare function toLcov(lcov: LcovData): string;

package/dist/src/lcov-merge.mjs

@@ -0,0 +1,29 @@
+/** Merges multiple LcovData maps by summing hit counts per file per line. */
+export function mergeLcov(reports) {
+    const merged = 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) {
+    const lines = [];
+    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/dist/src/lcov-parser.d.mts

@@ -0,0 +1,8 @@
+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 declare function parseLcov(text: string, stripPrefixes?: string[]): LcovData;

package/dist/src/lcov-parser.mjs

@@ -0,0 +1,44 @@
+/**
+ * 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, stripPrefixes = []) {
+    const result = new Map();
+    let currentLines = 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) {
+    return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}

package/dist/src/load-artifacts.d.mts

@@ -0,0 +1,9 @@
+/** Recursively collects all lcov.info files under the given directory. */
+export declare function collectLcovFiles(dir: string): string[];
+/**
+ * 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 declare function buildStripPrefixes(extra?: string[]): string[];

package/dist/src/load-artifacts.mjs

@@ -0,0 +1,41 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+/** Recursively collects all lcov.info files under the given directory. */
+export function collectLcovFiles(dir) {
+    const results = [];
+    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.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 = []) {
+    const prefixes = 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/dist/src/patch-coverage.d.mts

@@ -0,0 +1,5 @@
+import type { BucketResult, CoverageRule, DiffLines, FileCoverageResult, LcovData } from "./types.mts";
+export declare function computePatchCoverage(diff: DiffLines, lcov: LcovData, rules: CoverageRule[]): {
+    buckets: BucketResult[];
+    informational: FileCoverageResult[];
+};

package/dist/src/patch-coverage.mjs

@@ -0,0 +1,65 @@
+import { matchRule } from "./rules.mjs";
+export function computePatchCoverage(diff, lcov, rules) {
+    const bucketMap = new Map();
+    const informational = [];
+    for (const [file, changedLineSet] of diff) {
+        const fileLines = lcov.get(file);
+        if (fileLines === undefined)
+            continue; // not in lcov scope — skip
+        const coverable = [];
+        const uncoveredLines = [];
+        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 = {
+            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/dist/src/report.d.mts

@@ -0,0 +1,4 @@
+import type { CoverageCheckResult } from "./types.mts";
+export declare const COMMENT_MARKER = "<!-- coverage-check -->";
+export declare function collapseRanges(lines: number[]): string;
+export declare function renderFailureComment(result: CoverageCheckResult, runUrl: string, now?: string): string;

package/dist/src/report.mjs

@@ -0,0 +1,65 @@
+export const COMMENT_MARKER = "<!-- coverage-check -->";
+export function collapseRanges(lines) {
+    if (lines.length === 0)
+        return "";
+    const sorted = [...lines].sort((a, b) => a - b);
+    const ranges = [];
+    let start = sorted[0];
+    let end = start;
+    for (let i = 1; i < sorted.length; i++) {
+        const n = sorted[i];
+        if (n === end + 1) {
+            end = n;
+        }
+        else {
+            ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
+            start = n;
+            end = n;
+        }
+    }
+    ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
+    return ranges.join(", ");
+}
+function pct(bucket) {
+    if (bucket.coverable === 0)
+        return "—";
+    return `${((bucket.hit / bucket.coverable) * 100).toFixed(1)}% (${bucket.hit}/${bucket.coverable})`;
+}
+function renderFileList(files) {
+    return files
+        .filter((f) => f.uncoveredLines.length > 0)
+        .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
+        .join("\n");
+}
+export function renderFailureComment(result, runUrl, now = new Date().toISOString()) {
+    const failingBuckets = result.buckets.filter((b) => !b.passed);
+    const table = [
+        "| Workspace rule | Patch coverage | Threshold |",
+        "|---|---|---|",
+        ...failingBuckets.map((b) => `| \`${b.rule}\` | ${pct(b)} | ${b.threshold}% |`),
+    ].join("\n");
+    const sections = failingBuckets
+        .map((b) => {
+        const fileList = renderFileList(b.files);
+        return `**\`${b.rule}\`** (threshold ${b.threshold}%):\n${fileList || "_No line-level data available_"}`;
+    })
+        .join("\n\n");
+    const informationalLines = result.informational
+        .filter((f) => f.uncoveredLines.length > 0)
+        .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
+        .join("\n");
+    const informationalSection = informationalLines.length > 0
+        ? `\n<details><summary>Informational (no rule)</summary>\n\n${informationalLines}\n</details>`
+        : "";
+    return `${COMMENT_MARKER}
+## Patch coverage gate failed
+
+${table}
+
+### Uncovered lines
+
+${sections}
+${informationalSection}
+
+_Last updated: ${now} · [Workflow run](${runUrl})_`;
+}

package/dist/src/rules.d.mts

@@ -0,0 +1,4 @@
+import type { CoverageRule } from "./types.mts";
+export declare function loadRules(rulesPath: string): CoverageRule[];
+/** Returns the first matching rule for a repo-root-relative file path, or null. */
+export declare function matchRule(file: string, rules: CoverageRule[]): CoverageRule | null;

package/dist/src/rules.mjs

@@ -0,0 +1,30 @@
+/* c8 ignore next */
+import { readFileSync } from "node:fs";
+import { matchesGlob } from "node:path";
+import yaml from "js-yaml";
+export function loadRules(rulesPath) {
+    const text = readFileSync(rulesPath, "utf8");
+    const parsed = yaml.load(text);
+    if (!Array.isArray(parsed?.rules)) {
+        throw new Error(`${rulesPath}: expected a 'rules' array`);
+    }
+    for (let i = 0; i < parsed.rules.length; i++) {
+        const rule = parsed.rules[i];
+        if (typeof rule?.paths !== "string") {
+            throw new Error(`${rulesPath}: rule[${i}].paths must be a string`);
+        }
+        const min = rule.patch_coverage_min;
+        if (!Number.isFinite(min) || min < 0 || min > 100) {
+            throw new Error(`${rulesPath}: rule[${i}].patch_coverage_min must be a number between 0 and 100`);
+        }
+    }
+    return parsed.rules;
+}
+/** Returns the first matching rule for a repo-root-relative file path, or null. */
+export function matchRule(file, rules) {
+    for (const rule of rules) {
+        if (matchesGlob(file, rule.paths))
+            return rule;
+    }
+    return null;
+}

package/dist/src/s3-suite-store.d.mts

@@ -0,0 +1,28 @@
+import type { SuitePutMeta, SuiteStore } from "./suite-store.mts";
+type ClientLike = {
+    send(cmd: object): Promise<unknown>;
+};
+export type S3SuiteStoreOptions = {
+    bucket: string;
+    prefix?: string;
+    region?: string;
+    /** Inject a custom S3 client (e.g. for testing). */
+    client?: ClientLike;
+};
+export declare class S3SuiteStore implements SuiteStore {
+    private readonly bucket;
+    private readonly prefix;
+    private readonly client;
+    constructor({ bucket, prefix, region, client }: S3SuiteStoreOptions);
+    private key;
+    list(): Promise<string[]>;
+    get(suite: string, opts?: {
+        sha?: string;
+        branch?: string;
+    }): Promise<Buffer | null>;
+    put(suite: string, lcov: Buffer, meta?: SuitePutMeta): Promise<void>;
+    private getLegacy;
+    private shouldWritePointer;
+    private readPointer;
+}
+export {};

package/dist/src/s3-suite-store.mjs

@@ -0,0 +1,147 @@
+import { GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
+import { assertSafePathComponent, assertValidTimestamp, encodeBranchName, isNewerTimestamp, } from "./suite-store.mjs";
+import { bodyToBuffer, isNotFound } from "./s3-utils.mjs";
+export class S3SuiteStore {
+    bucket;
+    prefix;
+    client;
+    constructor({ bucket, prefix, region, client }) {
+        this.bucket = bucket;
+        this.prefix = prefix ? prefix.replace(/\/+$/, "") : "";
+        this.client = client ?? new S3Client({ region });
+    }
+    key(...parts) {
+        return this.prefix ? [this.prefix, ...parts].join("/") : parts.join("/");
+    }
+    async list() {
+        const pfx = this.prefix ? `${this.prefix}/` : "";
+        const suites = [];
+        let continuationToken;
+        do {
+            const resp = (await this.client.send(new ListObjectsV2Command({
+                Bucket: this.bucket,
+                Prefix: pfx,
+                Delimiter: "/",
+                ...(continuationToken ? { ContinuationToken: continuationToken } : {}),
+            })));
+            suites.push(...(resp.CommonPrefixes ?? [])
+                .map((cp) => cp.Prefix?.replace(pfx, "").replace(/\/$/, "") ?? "")
+                .filter(Boolean));
+            continuationToken = resp.IsTruncated ? resp.NextContinuationToken : undefined;
+        } while (continuationToken);
+        return suites;
+    }
+    async get(suite, opts) {
+        assertSafePathComponent(suite, "suite");
+        if (opts?.sha !== undefined)
+            assertSafePathComponent(opts.sha, "sha");
+        let sha = opts?.sha;
+        if (!sha) {
+            const branch = opts?.branch ?? "main";
+            try {
+                const pointer = await this.readPointer(suite, branch);
+                assertSafePathComponent(pointer.sha, "sha");
+                sha = pointer.sha;
+            }
+            catch (err) {
+                if (isNotFound(err))
+                    return this.getLegacy(suite);
+                throw err;
+            }
+        }
+        try {
+            const resp = (await this.client.send(new GetObjectCommand({
+                Bucket: this.bucket,
+                Key: this.key(suite, "sha", sha, "lcov.info"),
+            })));
+            return bodyToBuffer(resp.Body);
+        }
+        catch (err) {
+            if (isNotFound(err))
+                return null;
+            throw err;
+        }
+    }
+    async put(suite, lcov, meta) {
+        assertSafePathComponent(suite, "suite");
+        if (meta === undefined) {
+            await this.client.send(new PutObjectCommand({
+                Bucket: this.bucket,
+                Key: this.key(suite, "lcov.info"),
+                Body: lcov,
+                ContentType: "text/plain",
+            }));
+            return;
+        }
+        const { sha, branch } = meta;
+        assertSafePathComponent(sha, "sha");
+        const ts = meta.timestamp ?? new Date().toISOString();
+        assertValidTimestamp(ts);
+        await this.client.send(new PutObjectCommand({
+            Bucket: this.bucket,
+            Key: this.key(suite, "sha", sha, "lcov.info"),
+            Body: lcov,
+            ContentType: "text/plain",
+        }));
+        if (!(await this.shouldWritePointer(suite, branch, ts)))
+            return;
+        await this.client.send(new PutObjectCommand({
+            Bucket: this.bucket,
+            Key: this.key(suite, "branch", encodeBranchName(branch), "latest.json"),
+            Body: Buffer.from(JSON.stringify({ sha, timestamp: ts }), "utf8"),
+            ContentType: "application/json",
+        }));
+    }
+    async getLegacy(suite) {
+        try {
+            const resp = (await this.client.send(new GetObjectCommand({
+                Bucket: this.bucket,
+                Key: this.key(suite, "lcov.info"),
+            })));
+            return bodyToBuffer(resp.Body);
+        }
+        catch (err) {
+            if (isNotFound(err))
+                return null;
+            throw err;
+        }
+    }
+    async shouldWritePointer(suite, branch, incomingTimestamp) {
+        try {
+            const resp = (await this.client.send(new GetObjectCommand({
+                Bucket: this.bucket,
+                Key: this.key(suite, "branch", encodeBranchName(branch), "latest.json"),
+            })));
+            if (resp.Body === undefined)
+                return true;
+            const body = await bodyToBuffer(resp.Body);
+            const current = JSON.parse(body.toString("utf8"));
+            return !isNewerTimestamp(current.timestamp, incomingTimestamp);
+        }
+        catch (err) {
+            if (isNotFound(err))
+                return true;
+            throw err;
+        }
+    }
+    async readPointer(suite, branch) {
+        const keys = [
+            this.key(suite, "branch", encodeBranchName(branch), "latest.json"),
+            this.key(suite, "branch", branch, "latest.json"),
+        ];
+        let lastNotFound;
+        for (const key of keys) {
+            try {
+                const resp = (await this.client.send(new GetObjectCommand({ Bucket: this.bucket, Key: key })));
+                const body = await bodyToBuffer(resp.Body);
+                return JSON.parse(body.toString("utf8"));
+            }
+            catch (err) {
+                if (!isNotFound(err))
+                    throw err;
+                lastNotFound = err;
+            }
+        }
+        throw lastNotFound;
+    }
+}

package/dist/src/s3-utils.d.mts

@@ -0,0 +1,2 @@
+export declare function isNotFound(err: unknown): boolean;
+export declare function bodyToBuffer(body: unknown): Promise<Buffer>;

package/dist/src/s3-utils.mjs

@@ -0,0 +1,14 @@
+import { Readable } from "node:stream";
+import { buffer } from "node:stream/consumers";
+export function isNotFound(err) {
+    return err instanceof Error && (err.name === "NoSuchKey" || err.name === "NotFound");
+}
+export async function bodyToBuffer(body) {
+    if (body instanceof Readable)
+        return buffer(body);
+    if (body instanceof Uint8Array)
+        return Buffer.from(body);
+    if (body instanceof Blob)
+        return Buffer.from(await body.arrayBuffer());
+    throw new Error("unexpected S3 response body type");
+}

package/dist/src/step-summary.d.mts

@@ -0,0 +1,9 @@
+import type { LcovData } from "./types.mts";
+import type { CoverageCheckResult } from "./types.mts";
+export type SuiteSource = {
+    suite: string;
+    source: "fresh" | "store";
+    lcov: LcovData;
+};
+export declare function buildSummaryMarkdown(suiteSources: SuiteSource[], result: CoverageCheckResult, runUrl: string, branch?: string): string;
+export declare function writeSummary(summaryFile: string, suiteSources: SuiteSource[], result: CoverageCheckResult, runUrl: string, branch?: string): void;

package/dist/src/step-summary.mjs

@@ -0,0 +1,70 @@
+import { appendFileSync } from "node:fs";
+function suiteTotals(lcov) {
+    let hit = 0;
+    let total = 0;
+    for (const lines of lcov.values()) {
+        for (const count of lines.values()) {
+            total++;
+            if (count > 0)
+                hit++;
+        }
+    }
+    return { hit, total };
+}
+function pctStr(hit, total) {
+    if (total === 0)
+        return "—";
+    return `${((hit / total) * 100).toFixed(1)}% (${hit}/${total})`;
+}
+function escMd(s) {
+    return s.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+}
+function codeSpan(s) {
+    const escaped = escMd(s);
+    const longestRun = Math.max(0, ...Array.from(escaped.matchAll(/`+/g), (m) => m[0].length));
+    if (longestRun === 0)
+        return `\`${escaped}\``;
+    const ticks = "`".repeat(longestRun + 1);
+    return `${ticks} ${escaped} ${ticks}`;
+}
+export function buildSummaryMarkdown(suiteSources, result, runUrl, branch = "main") {
+    const suiteRows = suiteSources
+        .map(({ suite, source, lcov }) => {
+        const { hit, total } = suiteTotals(lcov);
+        const sourceLabel = source === "fresh" ? "fresh" : `store (${escMd(branch)})`;
+        return `| ${codeSpan(suite)} | ${sourceLabel} | ${pctStr(hit, total)} |`;
+    })
+        .join("\n");
+    const suiteTable = [
+        "| Suite | Source | Line coverage |",
+        "|---|---|---|",
+        suiteRows || "| — | — | — |",
+    ].join("\n");
+    const ruleRows = result.buckets
+        .map((b) => {
+        const status = b.passed ? "✅" : "❌";
+        const pct = b.coverable > 0 ? `${((b.hit / b.coverable) * 100).toFixed(1)}%` : "—";
+        return `| ${codeSpan(b.rule)} | ${b.threshold}% | ${pct} | ${status} |`;
+    })
+        .join("\n");
+    const ruleTable = [
+        "| Rule | Threshold | Patch coverage | Status |",
+        "|---|---|---|---|",
+        ruleRows || "| — | — | — | — |",
+    ].join("\n");
+    const overall = result.passed ? "✅ passed" : "❌ failed";
+    const runLink = runUrl !== "N/A" ? `\n\n_[View run](${runUrl})_` : "";
+    return `## Coverage summary — ${overall}
+
+### Suite totals
+
+${suiteTable}
+
+### Patch coverage
+
+${ruleTable}${runLink}
+`;
+}
+export function writeSummary(summaryFile, suiteSources, result, runUrl, branch) {
+    appendFileSync(summaryFile, buildSummaryMarkdown(suiteSources, result, runUrl, branch), "utf8");
+}