flagrm 0.3.0 → 0.4.1

package/dist/core/verify/commands.js

@@ -4,16 +4,21 @@
  * tests of the OFF path is part of removing a flag, losing any other test is not.
  * A changed test file none of whose tests ran is a warning too: the test
  * command doesn't cover it, so verify didn't check the edit.
+ *
+ * The `lint` check: a failing lint command fails. One that already failed at
+ * the baseline (lint debt) only warns, unless its log has error lines the
+ * baseline's didn't.
  */
 import fs from "node:fs";
 import path from "node:path";
-import { errorExcerpt, templateCheckGap } from "../baseline.js";
+import { errorExcerpt, logLines, looksLikeError, templateCheckGap } from "../baseline.js";
 import { projectCommands } from "../config-snapshot.js";
 import { escapeRegExp, isTestPath } from "../scan.js";
+import { RUN_CHECK_ID, } from "../types.js";
 import { relativePath } from "../util.js";
 import { checkResult, configFindings, plural, skippedResult } from "./context.js";
-import { classifyRemovedTests } from "./removed-tests.js";
-import { diffTestNames, shortTestNames, splitFailures } from "./test-results.js";
+import { classifyRemovedTests, declaredTestDiff } from "./removed-tests.js";
+import { diffTestNames, hasTestNames, shortTestNames, splitFailures } from "./test-results.js";
 function failedRunFindings(run) {
     const findings = [
         {
@@ -35,8 +40,9 @@ function setupFinding(run) {
     return { severity: "info", message: `setup problem: ${run.failure?.message}`, project: run.project };
 }
 /** No command to run: skipped, unless the baseline had one, which is worth a warning. */
-function noCommandResult(v, id) {
-    const summary = `no ${id === "build" ? "build" : "test"} command configured`;
+function noCommandResult(v, kind) {
+    const id = RUN_CHECK_ID[kind];
+    const summary = `no ${kind} command configured`;
     const findings = configFindings(v, id);
     return findings.length ? checkResult(id, summary, findings) : skippedResult(id, summary);
 }
@@ -63,15 +69,104 @@ export function buildCheck(v) {
         : `${runs.map((r) => r.project).join(", ")} built successfully`;
     return checkResult("build", summary, findings);
 }
+export function lintCheck(v) {
+    const runs = v.runs.filter((r) => r.check === "lint");
+    if (runs.length === 0)
+        return noCommandResult(v, "lint");
+    const findings = [];
+    let failed = 0;
+    let known = 0;
+    for (const run of runs) {
+        if (run.exitCode === 0)
+            continue;
+        const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "lint");
+        // A setup problem, or a run cut short, is no lint debt: it fails even when the baseline failed too.
+        if (run.failure || run.interrupted || !before || before.exitCode === 0 || before.failure || before.interrupted) {
+            failed++;
+            findings.push(...failedRunFindings(run));
+            if (!before) {
+                findings.push({
+                    severity: "info",
+                    message: "the baseline has no lint run to compare with (lint configured after it, or baseline --no-checks), so every lint error fails: show the user",
+                    project: run.project,
+                });
+            }
+            continue;
+        }
+        const debt = knownLintFindings(before, run);
+        if (debt.some((f) => f.severity === "fail"))
+            failed++;
+        else
+            known++;
+        findings.push(...debt);
+    }
+    findings.push(...configFindings(v, "lint"));
+    const summary = failed
+        ? `${plural(failed, "lint run")} failed`
+        : known
+            ? `${plural(known, "lint run fails", "lint runs fail")} as at the baseline`
+            : `${runs.map((r) => r.project).join(", ")} linted cleanly`;
+    return checkResult("lint", summary, findings);
+}
+/**
+ * A lint run that failed at the baseline too: compared line by line with the
+ * baseline's log. Numbers are masked first, so an old error whose line moved
+ * (`40:5` → `30:5`) or a changed problem count isn't new. Lines are counted,
+ * not just compared: ESLint prints an error without its file, so a second
+ * identical one is still new. A new line that looks like an error fails; other
+ * new lines only warn. At most 20 are listed, errors first.
+ */
+function knownLintFindings(before, run) {
+    const was = logLines(before.log);
+    if (!was) {
+        return [
+            {
+                severity: "warn",
+                message: `lint already failed at the baseline; its log wasn't found, so new errors can't be told (log: ${run.log})`,
+                project: run.project,
+                file: run.log,
+            },
+        ];
+    }
+    const mask = (line) => line.replace(/\d+/g, "#");
+    const seen = new Map();
+    for (const line of was)
+        seen.set(mask(line), (seen.get(mask(line)) ?? 0) + 1);
+    const added = (logLines(run.log) ?? []).filter((line) => {
+        const left = seen.get(mask(line)) ?? 0;
+        seen.set(mask(line), left - 1);
+        return left <= 0;
+    });
+    const errors = added.filter(looksLikeError);
+    const listed = [...errors, ...added.filter((line) => !looksLikeError(line))].slice(0, 20);
+    const head = errors.length
+        ? {
+            severity: "fail",
+            message: `lint already failed at the baseline, but ${plural(errors.length, "error line is", "error lines are")} new: fix ${errors.length === 1 ? "it" : "them"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        }
+        : {
+            severity: "warn",
+            message: `lint already failed at the baseline: ${added.length ? `${plural(added.length, "new line")} in the log, none an error` : "no new lines in the log"} (log: ${run.log})`,
+            project: run.project,
+            file: run.log,
+        };
+    return [
+        head,
+        ...listed.map((line) => ({ severity: "info", message: `new: ${line}`, project: run.project })),
+    ];
+}
 export function compareTests(v) {
     const out = [];
     for (const run of v.runs.filter((r) => r.check === "test")) {
         const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
         const after = run.results;
+        const counted = (r) => (r && (r.total > 0 || hasTestNames(r)) ? r.total : undefined);
         const comparison = {
             project: run.project,
-            before: before?.total,
-            after: after?.total,
+            before: counted(before),
+            after: counted(after),
             removed: [],
             added: [],
             deleted: [],
@@ -88,16 +183,40 @@ export function compareTests(v) {
             comparison.newFailures = shortTestNames(failures.new);
             comparison.knownFailures = shortTestNames(failures.known);
         }
-        if (before && after) {
+        const projectRoot = v.projects.find(({ ctx }) => ctx.name === run.project)?.ctx.root;
+        const removedCtx = {
+            root: v.root,
+            sha: v.baseline.git.sha,
+            changedFiles: projectRoot
+                ? (v.changedFiles ?? []).filter((rel) => !path.relative(projectRoot, path.join(v.root, rel)).startsWith(".."))
+                : v.changedFiles,
+            names: v.baseline.names,
+            testConfigChanged: v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project),
+        };
+        if (hasTestNames(before) && hasTestNames(after)) {
             const { removed, added } = diffTestNames(before.names, after.names);
             Object.assign(comparison, { removed, added });
-            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, {
-                root: v.root,
-                sha: v.baseline.git.sha,
-                changedFiles: v.changedFiles,
-                names: v.baseline.names,
-                testConfigChanged: v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project),
-            }));
+            Object.assign(comparison, classifyRemovedTests(removed, added, after.names, removedCtx));
+        }
+        else {
+            // No names from result files on both sides: the test files' declarations show what the diff deleted or renamed.
+            const declared = declaredTestDiff(removedCtx);
+            const { renamed } = classifyRemovedTests(declared.removed, declared.added, declared.now, removedCtx, declared.files);
+            const from = new Set(renamed.map((r) => r.from));
+            Object.assign(comparison, {
+                removed: declared.removed,
+                added: declared.added,
+                renamed,
+                deleted: declared.removed.filter((name) => !from.has(name)),
+            });
+            if (comparison.before !== undefined && comparison.after !== undefined) {
+                const gap = comparison.before - comparison.after - comparison.deleted.length + (declared.added.length - renamed.length);
+                if (gap > 0) {
+                    comparison.missing = gap;
+                    if (declared.rows)
+                        comparison.missingMayBeRows = true;
+                }
+            }
         }
         out.push(comparison);
     }
@@ -106,13 +225,19 @@ export function compareTests(v) {
 /**
  * For a test run that exited non-zero: its failed tests split into the ones
  * that already failed at the baseline and new ones. Undefined when that can't
- * be told (no result files now or at the baseline, or none of them failed, so
+ * be told (no results now or at the baseline, from different sources, or none of them failed, so
  * the command broke some other way).
  */
 function splitBaselineFailures(v, run) {
     const before = v.baseline.checks?.find((c) => c.project === run.project && c.check === "test")?.results;
     if (!before || !run.results?.failed)
         return undefined;
+    // Counts without all their names (a log may not name every failing test) can't be split.
+    if (run.results.failedNames.length < run.results.failed || before.failedNames.length < before.failed)
+        return undefined;
+    // Names from a log and from result files aren't spelled alike, so they can't be matched.
+    if ((before.source ?? "files") !== (run.results.source ?? "files"))
+        return undefined;
     return splitFailures(before.failedNames, run.results.failedNames);
 }
 /**
@@ -125,7 +250,10 @@ function failedTestFindings(run, failures, accepted = false) {
         .slice(0, 20)
         .map((name) => ({ severity: "info", message: `${prefix}: ${name}`, project: run.project }));
     if (!failures) {
-        return [...failedRunFindings(run).slice(0, 1), ...list(run.results?.failedNames ?? [], "failed")];
+        const names = run.results?.failedNames ?? [];
+        const [head, ...excerpt] = failedRunFindings(run);
+        // Without failing test names, the log's error lines are all there is to go on; the caller adds a setup problem.
+        return [head, ...(names.length || run.failure ? [] : excerpt), ...list(names, "failed")];
     }
     if (failures.new.length === 0) {
         return [
@@ -160,7 +288,7 @@ function failedTestFindings(run, failures, accepted = false) {
 export function testsCheck(v, comparisons) {
     const runs = v.runs.filter((r) => r.check === "test");
     if (runs.length === 0)
-        return noCommandResult(v, "tests");
+        return noCommandResult(v, "test");
     const findings = configFindings(v, "tests");
     let failed = 0;
     let known = 0;
@@ -178,14 +306,14 @@ export function testsCheck(v, comparisons) {
         const ctx = entry?.ctx;
         const testResults = entry && projectCommands(entry.adapter, entry.ctx).testResults;
         const comparison = comparisons.find((c) => c.project === run.project);
-        if (testResults && !run.results) {
+        if (testResults && !hasTestNames(run.results)) {
             findings.push({
                 severity: "warn",
-                message: `no test results found at ${testResults}, so the test count was not compared`,
+                message: `no test results found at ${testResults}, so tests were not compared by name${run.results ? " (failing tests and counts read from the log)" : ""}`,
                 project: run.project,
             });
         }
-        else if (run.results && comparison?.before === undefined) {
+        else if (hasTestNames(run.results) && comparison?.before === undefined) {
             findings.push({
                 severity: "info",
                 message: "the baseline has no test results to compare with (run `flagrm baseline` before the removal)",
@@ -203,7 +331,16 @@ export function testsCheck(v, comparisons) {
                 findings.push({ severity: "info", message: `no longer runs: ${name}`, project: run.project });
             }
         }
-        if (run.results && ctx) {
+        const missing = comparison?.missing ?? 0;
+        if (missing > 0 && comparison) {
+            const configChanged = v.originalConfigChanges.some((c) => c.check === "tests" && c.project === run.project);
+            findings.push({
+                severity: configChanged || comparison.missingMayBeRows ? "info" : "warn",
+                message: `${plural(missing, "more test stopped running", "more tests stopped running")} than the diff deletes (${comparison.before} → ${comparison.after}, ${comparison.deleted.length} deleted): account for ${missing === 1 ? "it" : "them"} in the PR${comparison.missingMayBeRows ? " (data rows and .each cases count separately, so this may be them)" : ""}`,
+                project: run.project,
+            });
+        }
+        if (hasTestNames(run.results) && ctx) {
             for (const file of changedTestFiles(v, ctx.root)) {
                 if (testFileRan(file, ctx.root, run.results.names))
                     continue;
@@ -226,6 +363,7 @@ export function testsCheck(v, comparisons) {
             c.renamed.length && `${c.renamed.length} renamed`,
             c.excludedByConfig.length && `${c.excludedByConfig.length} excluded by config`,
             c.unexplained.length && `${c.unexplained.length} unexplained`,
+            c.missing && `${c.missing} unaccounted for`,
         ].filter(Boolean);
         return `${c.project} ${c.before} → ${c.after}${why.length ? `: ${why.join(", ")}` : ""}`;
     });

package/dist/core/verify/coverage.js

@@ -0,0 +1,92 @@
+/**
+ * The `coverage` check: a file the removal changed that no build, test or
+ * lint command checks is a warning. A project covers a file inside its path
+ * when it ran a command in this verify (or has one `--skip` left out) and one
+ * of its `covers` globs (relative to its path; default: everything) matches
+ * the file. A file that was already dirty at the baseline and hasn't changed
+ * since is no edit of the removal. Outside every project, deleted files and
+ * documentation have nothing for a command to check.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { excludeMatcher } from "../change-filter.js";
+import { projectCommands } from "../config-snapshot.js";
+import { blobIds } from "../git.js";
+import { RUN_CHECK_ID } from "../types.js";
+import { relativePath } from "../util.js";
+import { checkResult, plural, skippedResult } from "./context.js";
+/** More uncovered files than this are counted per top-level directory instead. */
+const MAX_FILES = 20;
+const UNCHECKED = "no build, test or lint command checks";
+const DOCS = /\.(?:md|mdx|markdown|txt|rst|adoc)$/i;
+export function coverageCheck(v) {
+    if (!v.changedFiles)
+        return skippedResult("coverage", "no baseline commit to diff against");
+    const skipped = Object.keys(RUN_CHECK_ID).filter((kind) => v.skip?.has(RUN_CHECK_ID[kind]));
+    if (skipped.length === 3)
+        return skippedResult("coverage", "build, tests and lint skipped (--skip), so no command ran");
+    const ran = new Set(v.runs.map((r) => r.project));
+    const projects = v.projects.map(({ adapter, ctx }) => {
+        const covers = ctx.project.covers;
+        const commands = projectCommands(adapter, ctx);
+        return {
+            name: ctx.name,
+            root: ctx.root,
+            // A command --skip left out would have checked the file: no reason to warn about the config.
+            ran: ran.has(ctx.name) || skipped.some((kind) => commands[kind]),
+            covers: covers ? excludeMatcher(covers.map(coversGlob)) : () => true,
+        };
+    });
+    const uncovered = [];
+    for (const file of removalFiles(v, v.changedFiles)) {
+        const containing = projects
+            .map((p) => ({ ...p, rel: relativePath(p.root, path.join(v.root, file)) }))
+            .filter((p) => p.rel !== ".." && !p.rel.startsWith("../") && !path.isAbsolute(p.rel));
+        if (containing.some((p) => p.ran && p.covers(p.rel)))
+            continue;
+        // Outside every project, documentation and deleted files have nothing for a command to check.
+        if (containing.length === 0 && (DOCS.test(file) || !fs.existsSync(path.join(v.root, file))))
+            continue;
+        const innermost = containing.sort((a, b) => b.root.length - a.root.length)[0];
+        uncovered.push({ file, project: innermost?.name });
+    }
+    if (uncovered.length === 0)
+        return checkResult("coverage", "every changed file is built, tested or linted", []);
+    const findings = uncovered.length > MAX_FILES
+        ? byDirectory(uncovered)
+        : uncovered.map(({ file, project }) => ({
+            severity: "warn",
+            message: `${file}: ${UNCHECKED} it`,
+            ...(project ? { project } : {}),
+        }));
+    return checkResult("coverage", `${plural(uncovered.length, "changed file")} no command checks`, findings);
+}
+/** The changed files without the ones dirty at the baseline and unchanged since (all of them, for a baseline without their hashes). */
+function removalFiles(v, changed) {
+    const { dirtyFiles = [], dirtyHashes } = v.baseline.git ?? {};
+    const dirty = new Set(dirtyFiles);
+    const candidates = changed.filter((rel) => dirty.has(rel));
+    if (candidates.length === 0)
+        return changed;
+    if (!dirtyHashes)
+        return changed.filter((rel) => !dirty.has(rel));
+    const now = blobIds(v.root, candidates);
+    return changed.filter((rel) => !dirty.has(rel) || !(rel in dirtyHashes) || now[rel] !== dirtyHashes[rel]);
+}
+/** A `covers` entry as a glob: `./src/**` is how the rest of the config writes paths, and `./` or `.` is everything. */
+function coversGlob(glob) {
+    const rel = glob.replace(/^\.\//, "").replace(/\/+$/, "");
+    return rel === "" || rel === "." ? "**" : rel;
+}
+/** One warning per top-level directory (`.` for files in the root) with its count. */
+function byDirectory(uncovered) {
+    const counts = new Map();
+    for (const { file } of uncovered) {
+        const slash = file.indexOf("/");
+        const dir = slash === -1 ? "." : `${file.slice(0, slash)}/`;
+        counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    return [...counts]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([dir, n]) => ({ severity: "warn", message: `${dir}: ${plural(n, "changed file")} ${UNCHECKED}` }));
+}

package/dist/core/verify/index.js

@@ -9,9 +9,11 @@ import { flagDir, readBaseline, runChecks, verifyPath } from "../baseline.js";
 import { changeFilter, changeFilterAt } from "../change-filter.js";
 import { configChanges as configChangesSince, configSnapshot } from "../config-snapshot.js";
 import { changedFilesSince, gitState, treeFingerprint } from "../git.js";
-import { CHECK_IDS, JSON_SCHEMA_VERSION, } from "../types.js";
-import { buildCheck, compareTests, testsCheck } from "./commands.js";
+import { dropRuns, findRuns, plannedRuns, reuseRuns, runsKey, saveRuns } from "../run-cache.js";
+import { CHECK_IDS, JSON_SCHEMA_VERSION, RUN_CHECK_ID, } from "../types.js";
+import { buildCheck, compareTests, lintCheck, testsCheck } from "./commands.js";
 import { skippedResult } from "./context.js";
+import { coverageCheck } from "./coverage.js";
 import { deadCodeCheck } from "./dead-code.js";
 import { leftoversCheck } from "./leftovers.js";
 export async function verifyFlag(root, projects, flag, options = {}) {
@@ -23,8 +25,12 @@ export async function verifyFlag(root, projects, flag, options = {}) {
     // flagrm's setup files and `exclude`d paths (the config's and --exclude) aren't part of the removal.
     const ignore = changeFilter(projects[0]?.ctx.config);
     const changedFiles = baseline.git.sha ? changedFilesSince(root, baseline.git.sha, ignore) : undefined;
-    const only = [...(skip.has("build") ? [] : ["build"]), ...(skip.has("tests") ? [] : ["test"])];
-    const runs = only.length ? await runChecks(projects, path.join(flagDir(root, flag), "verify"), only) : [];
+    const only = ["build", "test", "lint"].filter((check) => !skip.has(RUN_CHECK_ID[check]));
+    // Before the commands: the key is the tree they run on.
+    const key = only.length ? runsKey(root, projects) : undefined;
+    const found = key && options.reuse !== false ? findRuns(root, projects, key, plannedRuns(projects, only)) : undefined;
+    const logDir = path.join(flagDir(root, flag), "verify");
+    const runs = found ? reuseRuns(found, logDir) : only.length ? await runChecks(projects, logDir, only) : [];
     // The fingerprint, though, is the tree the Stop hook will see next, so take it
     // after the commands: a test report they write outside .gitignore is part of it.
     // The Stop hook compares it with its own, so take it exactly as the hook does: from the config file
@@ -33,12 +39,24 @@ export async function verifyFlag(root, projects, flag, options = {}) {
     const now = configSnapshot(projects);
     const configChanges = configChangesSince(baseline.acceptedConfig ?? baseline.config, now);
     const originalConfigChanges = baseline.acceptedConfig ? configChangesSince(baseline.config, now) : configChanges;
-    const v = { root, flag, projects, baseline, changedFiles, runs, configChanges, originalConfigChanges };
+    const v = {
+        root,
+        flag,
+        projects,
+        baseline,
+        changedFiles,
+        runs,
+        skip,
+        configChanges,
+        originalConfigChanges,
+    };
     const tests = compareTests(v);
     const run = {
         "dead-code": () => deadCodeCheck(v),
         build: () => buildCheck(v),
         tests: () => testsCheck(v, tests),
+        lint: () => lintCheck(v),
+        coverage: () => coverageCheck(v),
     };
     const checks = [];
     for (const id of CHECK_IDS) {
@@ -64,6 +82,15 @@ export async function verifyFlag(root, projects, flag, options = {}) {
         runs: runs.map(countsOnly),
         tests,
     };
+    // Only a full pass is worth reusing: a failure may be flaky or a stopped service.
+    if (key && report.status === "pass" && report.skipped.length === 0)
+        saveRuns(root, flag, projects, key, runs);
+    // A fresh run that fails on this tree outweighs a saved pass for it (`--no-reuse` after a machine change).
+    else if (key &&
+        !found &&
+        checks.some((c) => (c.id === "build" || c.id === "tests" || c.id === "lint") && c.status === "fail")) {
+        dropRuns(root, key);
+    }
     const file = verifyPath(root, flag);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`, "utf8");

package/dist/core/verify/log-results.js

@@ -0,0 +1,127 @@
+/**
+ * Test results from a test command's log, for a run without result files:
+ * the failing tests' names and the summary counts the common runners print
+ * (Karma, Jest, Vitest, `dotnet test`; Go and pytest failures without
+ * counts). Passing tests aren't in these logs, so only failing ones are named.
+ */
+import { JUNIT_SEPARATOR } from "./test-results.js";
+const vitestName = (name) => name.split(" > ").join(JUNIT_SEPARATOR);
+/** A failing test's name in one log line, per runner. */
+const FAILED = [
+    // Karma: `Chrome Headless 120.0.0.0 (Mac OS 10.15.7) CheckoutComponent places the order FAILED`
+    [/^\S.*? \d[\d.]* \((?:Mac OS|Linux|Windows|Ubuntu)[^)]*\) (.+?) FAILED$/, (m) => m[1]],
+    // Jest: `● CheckoutComponent › places the order`; its notices (`● Console`, `● Multiple configurations found:`) aren't tests
+    [/^● (.+)$/, (m) => (/^(?:Test suite failed to run|Console)$|:$/.test(m[1]) ? undefined : m[1])],
+    // Vitest: `FAIL  src/a.spec.ts > Suite > title` (optionally after a `|project|` tag) and `× Suite > title 12ms`
+    [/^FAIL\s+(?:\|[^|]+\|\s+)?\S+ > (.+)$/, (m) => vitestName(m[1])],
+    [/^[×✗] (.+ > .+?)(?: \d+ms)?$/, (m) => vitestName(m[1])],
+    // dotnet test: `Failed Shop.Tests.CheckoutTests.Quote(express: False) [12 ms]`
+    [/^Failed (\S.*?) \[(?:< ?)?[\d.,]+ (?:ms|s|m)\]$/, (m) => m[1]],
+    // go test: `--- FAIL: TestX (0.00s)`
+    [/^--- FAIL: (\S+)/, (m) => m[1]],
+    // pytest: `FAILED tests/test_a.py::test_x - AssertionError`
+    [/^FAILED (\S+::\S+)/, (m) => m[1]],
+];
+function count(parts, word) {
+    return Number(new RegExp(`(\\d+) ${word}`).exec(parts)?.[1] ?? 0);
+}
+/**
+ * The summary counts in one log line; `sum` for runners that print one
+ * summary per test project, `browser` for Karma's one summary per browser.
+ */
+function summary(line) {
+    // Karma, possibly several `\r`-separated progress updates: the last one counts.
+    const karma = [
+        ...line.matchAll(/(?:^|\r)\s*(?:(\S[^\r]*?):\s+)?Executed (\d+) of (\d+)(?: \((\d+) FAILED\))?(?: \(skipped (\d+)\))?/g),
+    ].pop();
+    if (karma) {
+        const failed = Number(karma[4] ?? 0);
+        return {
+            counts: { total: Number(karma[3]), passed: Number(karma[2]) - failed, failed, skipped: Number(karma[5] ?? 0) },
+            browser: karma[1] ?? "",
+        };
+    }
+    const jest = /^Tests:\s+(.*?)(\d+) total/.exec(line);
+    if (jest) {
+        return {
+            counts: {
+                total: Number(jest[2]),
+                passed: count(jest[1], "passed"),
+                failed: count(jest[1], "failed"),
+                skipped: count(jest[1], "skipped") + count(jest[1], "todo"),
+            },
+        };
+    }
+    const vitest = /^Tests\s+(.+)\((\d+)\)$/.exec(line);
+    if (vitest) {
+        return {
+            counts: {
+                total: Number(vitest[2]),
+                passed: count(vitest[1], "passed"),
+                failed: count(vitest[1], "failed"),
+                skipped: count(vitest[1], "skipped") + count(vitest[1], "todo"),
+            },
+        };
+    }
+    const dotnet = /^(?:Failed|Passed)!\s+-\s+Failed:\s+(\d+), Passed:\s+(\d+), Skipped:\s+(\d+), Total:\s+(\d+)/.exec(line);
+    if (dotnet) {
+        return {
+            counts: {
+                failed: Number(dotnet[1]),
+                passed: Number(dotnet[2]),
+                skipped: Number(dotnet[3]),
+                total: Number(dotnet[4]),
+            },
+            sum: true,
+        };
+    }
+    return undefined;
+}
+const add = (a, b) => ({
+    total: a.total + b.total,
+    passed: a.passed + b.passed,
+    failed: a.failed + b.failed,
+    skipped: a.skipped + b.skipped,
+});
+export function parseTestLog(text) {
+    const failed = new Set();
+    let counts;
+    const browsers = new Map();
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ANSI colors
+    for (const raw of text.replace(/\u001b\[[0-9;]*m/g, "").split(/\r?\n/)) {
+        const line = raw.trim();
+        const found = summary(line);
+        if (found?.browser !== undefined) {
+            // Several browsers each run every test: the last summary per browser counts, summed over browsers.
+            browsers.set(found.browser, found.counts);
+            counts = [...browsers.values()].reduce(add);
+        }
+        else if (found) {
+            counts = found.sum && counts ? add(counts, found.counts) : found.counts;
+        }
+        // Karma's progress updates share a line through `\r`: names are looked for in each part.
+        for (const part of line.split("\r")) {
+            for (const [pattern, name] of FAILED) {
+                const m = pattern.exec(part.trim());
+                const found = m && name(m);
+                if (found) {
+                    failed.add(found);
+                    break;
+                }
+            }
+        }
+    }
+    if (!counts && failed.size === 0)
+        return undefined;
+    const names = [...failed];
+    return {
+        total: counts?.total ?? 0,
+        passed: counts?.passed ?? 0,
+        failed: counts?.failed ?? names.length,
+        skipped: counts?.skipped ?? 0,
+        names,
+        failedNames: [...names],
+        files: [],
+        source: "log",
+    };
+}