probatio 0.1.2 → 0.2.0

package/dist/mutate/run.js

@@ -12,7 +12,8 @@ import { writeJavaCoverage } from "./java-coverage.js";
 import { writeRustCoverage } from "./rust-coverage.js";
 import { applyPatch, changedLines, chooseDirection, filesInDiff, git, restoreTree } from "./patch.js";
 import { killLabel } from "./kill-label.js";
-import { TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, campaignSummary, decideSuite, hasLineMap, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
+import { CONFIG_FILE, readProjectConfig } from "./project-config.js";
+import { UNVIABLE_NEXT, TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, campaignSummary, decideSuite, hasLineMap, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
 import { commandSuite, discoverSuite, nodeTestTimeoutMs, runDiscoveredSuite, sourceCandidates } from "./suites.js";
 import { duplicateTitles } from "./titles.js";
 export const reporterPath = fileURLToPath(new URL("./fail-reporter.mjs", import.meta.url));
@@ -41,7 +42,7 @@ export async function runMutants(options) {
         return failReport(options.outDir, "", options.commit, "that commit does not resolve");
     const commit = sha.stdout.trim();
     mkdirSync(options.outDir, { recursive: true });
-    const run = loadRun(options.outDir, commit, options.agent);
+    const run = loadRun(options, commit);
     if ("error" in run)
         return failReport(options.outDir, run.id, commit, run.error);
     const listed = listPatches(options.patchDirs);
@@ -52,6 +53,9 @@ export async function runMutants(options) {
         : listed.files;
     if (patchFiles.length === 0)
         return failReport(options.outDir, run.id, commit, "no patches");
+    const config = readProjectConfig(packageDir);
+    if ("error" in config)
+        return failReport(options.outDir, run.id, commit, config.error, undefined, `Fix ${CONFIG_FILE} and run the same command again.`);
     const gate = resolveSuite(packageDir, options);
     if (gate.action === "stop")
         return failReport(options.outDir, run.id, commit, gate.summary, undefined, gate.next, gate.suiteCommand);
@@ -67,6 +71,13 @@ export async function runMutants(options) {
     if ("error" in worktrees)
         return failReport(options.outDir, run.id, commit, worktrees.error);
     hidePaths(worktrees.dirs, repo, packageDir, options.hide ?? []);
+    // A cancelled run (MCP cancel, Ctrl-C) still removes its worktrees from the user's repo.
+    const onSignal = (signal) => {
+        removeWorktrees(repo, worktrees.dirs, options.outDir);
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
     const budgetMs = options.budgetMs ?? (options.maxMinutes == null ? null : options.maxMinutes * 60_000);
     let budgetStarted = 0;
     const overBudget = () => budgetMs !== null && budgetStarted !== 0 && Date.now() - budgetStarted > budgetMs;
@@ -113,7 +124,7 @@ export async function runMutants(options) {
                     const prior = history.get(id);
                     if (prior && reusable(prior, raw, treePkg)) {
                         startedMutants += 1;
-                        const reused = reusedResult(prior, commit, run.id, options.agent);
+                        const reused = normalizeResult(reusedResult(prior, commit, run.id, options.agent));
                         writeResult(options.outDir, reused);
                         progress(`reused ${id}`);
                         continue;
@@ -165,6 +176,8 @@ export async function runMutants(options) {
         });
     }
     finally {
+        process.removeListener("SIGTERM", onSignal);
+        process.removeListener("SIGINT", onSignal);
         removeWorktrees(repo, worktrees.dirs, options.outDir);
     }
 }
@@ -211,7 +224,7 @@ async function prepare(pkg, options, progress) {
         if (baseline.compileToken)
             return { ok: false, error: `baseline build failed (${baseline.compileToken})` };
         if (!baseline.report)
-            return { ok: false, error: baselineReportError(baseline.detail) };
+            return { ok: false, error: baselineReportError(baseline.detail, baseline.command || spec.command) };
         baselineFailed = baseline.report.failed.map((item) => item.name);
         if (collect && !existsSync(mapPath)) {
             const binary = binaryFromCommand(baseline.command || spec.command, pkg);
@@ -224,6 +237,10 @@ async function prepare(pkg, options, progress) {
         progress(`suite report tests=${baseline.report.tests}`);
         progress(baselineFailed.length > 0 ? `baseline failing ${baselineFailed.length}` : "baseline pass");
         if (baselineFailed.length > 0) {
+            const tool = missingToolFrom(baseline.detail, baseline.command || spec.command);
+            const unnamed = baselineFailed.every((name) => name === "command" || name === "::command");
+            if (tool && unnamed)
+                return { ok: false, error: `missing tool: ${tool}. baseline suite did not return a test report` };
             return { ok: false, error: "baseline already failing", baselineFailed, suiteCommand: spec.command };
         }
         if (collect && !existsSync(mapPath) && languageMapKind(spec.kind)) {
@@ -250,12 +267,13 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
     const raw = readFileSync(patchPath, "utf8");
     const files = filesInDiff(raw);
     const edited = changedLines(raw);
+    const located = edited.length > 0 ? edited : files;
     const mutantHash = sha256(raw);
     const base = () => ({
         id,
         outcome: "error",
         direction: null,
-        files,
+        files: located,
         killedBy: [],
         cause: null,
         next: "",
@@ -287,10 +305,12 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
                 return { ...base(), direction, outcome: "timeout", error: "build timed out", next: TIMEOUT_NEXT };
             // The baseline build already succeeded. A mutant that no longer builds cannot pass the suite.
             if (built.code !== 0)
-                return finishMutant(killed(base, direction, ["build"]), pkg, "", false, []);
+                return finishMutant(unviable(base, direction, "build"), pkg, "", false, []);
         }
         const picked = selectionFor(prep.coverage, edited.length > 0 ? edited : files);
-        const forced = options.onlyNames && options.onlyNames.length > 0 ? options.onlyNames : null;
+        const forced = options.onlyNames && options.onlyNames.length > 0
+            ? prep.spec.kind === "node" ? options.onlyNames.map(nodeTitle) : options.onlyNames
+            : null;
         if (!forced && picked.state === "uncovered") {
             return {
                 ...base(),
@@ -318,16 +338,34 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, la
         }
         // A compile error can leave the previous run's report on disk. That report is not this mutant.
         if (main.compileToken)
-            return finishMutant(killed(base, direction, [main.compileToken]), pkg, commands.join(" | "), false, []);
-        if (!main.report)
-            return { ...base(), direction, error: "test reporter returned nothing", command: commands.join(" | ") };
+            return finishMutant(unviable(base, direction, main.compileToken), pkg, commands.join(" | "), false, []);
+        if (!main.report) {
+            const detail = main.detail ? clip(main.detail) : "";
+            const tool = missingToolFrom(detail, main.command);
+            const error = tool
+                ? `missing tool: ${tool}`
+                : detail
+                    ? `test reporter returned nothing (${detail})`
+                    : "test reporter returned nothing";
+            return { ...base(), direction, error, command: commands.join(" | ") };
+        }
+        // A node name pattern that matches nothing passes the file. That is not a survivor.
+        // A requested describe block reports its leaf tests, so any test that ran counts.
+        if (forced && prep.spec.kind === "node" && main.report.names.every((name) => isNodeTestFile(name))) {
+            return { ...base(), direction, error: `no requested test ran (${forced.join(", ")})`, command: commands.join(" | ") };
+        }
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
         if (main.report.failed.length === 0)
             return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
+        // A test file that no longer links ran no test. It is the build failing, the same as javac rejecting it.
+        // Only a failure where code ran can kill. When none did, the mutant did not build.
+        const ran = main.report.failed.filter((item) => !item.staticLoad);
+        if (ran.length === 0)
+            return finishMutant(unviable(base, direction, "compiler"), pkg, commands.join(" | "), false, []);
         if (!options.confirm)
-            return finishMutant(killed(base, direction, main.report.failed.map((item) => failureId(pkg, item))), pkg, commands.join(" | "), whole, chosen);
-        const confirmed = await confirmFailures(pkg, options, main.report.failed, prep, limit, commands);
+            return finishMutant(killed(base, direction, ran.map((item) => failureId(pkg, item))), pkg, commands.join(" | "), whole, chosen);
+        const confirmed = await confirmFailures(pkg, options, ran, prep, limit, commands);
         const killedBy = confirmed.killed.map((item) => failureId(pkg, item));
         const flaky = confirmed.flaky.map((item) => failureId(pkg, item));
         const outcome = killedBy.length > 0 ? "killed" : "flaky";
@@ -355,16 +393,31 @@ function killed(base, direction, killedBy) {
     const label = killLabel(killedBy);
     return { ...base(), direction, outcome: "killed", killedBy, cause: label?.cause ?? "test", next: label?.next ?? "" };
 }
+/** The compiler rejected the mutant. `killedBy` names the compiler so the record says which one. */
+function unviable(base, direction, compiler) {
+    return { ...base(), direction, outcome: "unviable", killedBy: [compiler], cause: "build", next: UNVIABLE_NEXT };
+}
+/**
+ * Results written before `unviable` existed stored a compile failure as killed with cause build.
+ * Read them the new way so an old out dir does not count a compiler as a test.
+ */
+export function normalizeResult(result) {
+    if (result.outcome === "killed" && result.cause === "build")
+        return { ...result, outcome: "unviable", next: UNVIABLE_NEXT };
+    return result;
+}
 async function confirmFailures(pkg, options, failed, prep, timeoutMs, commands) {
     const counts = new Map();
     let wholeSuite = false;
     const named = new Map();
     const hungFiles = new Map();
+    const unloaded = new Map();
     for (const failure of failed) {
         const key = failure.file || "*";
         // A name filter skips the tests that left the handle open, so the file
         // timeout never comes back. Rerun that file with no name pattern.
-        const bucket = failure.fileTimeout ? hungFiles : named;
+        // A file that did not load has no test name to filter by either.
+        const bucket = failure.fileTimeout ? hungFiles : failure.fileLoad ? unloaded : named;
         const list = bucket.get(key) ?? [];
         list.push(failure);
         bucket.set(key, list);
@@ -378,13 +431,17 @@ async function confirmFailures(pkg, options, failed, prep, timeoutMs, commands)
         if (await rerunGroup(pkg, options, file, failures, counts, null, prep, timeoutMs, commands))
             wholeSuite = true;
     }
+    for (const [file, failures] of unloaded) {
+        if (await rerunGroup(pkg, options, file, failures, counts, null, prep, timeoutMs, commands, "load"))
+            wholeSuite = true;
+    }
     const killed = [];
     const flaky = [];
     for (const failure of failed)
         (counts.get(failureId(pkg, failure)) === 2 ? killed : flaky).push(failure);
     return { killed, flaky, wholeSuite };
 }
-async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, timeoutMs, commands) {
+async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, timeoutMs, commands, fileFailure = "timeout") {
     const files = file === "*" ? listTestFiles(pkg, options.testsDir, prep.spec) : [testArg(pkg, file, options.testsDir)];
     const isolated = { ...options, concurrency: 1 };
     let wholeSuite = false;
@@ -396,20 +453,23 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
             wholeSuite = true;
         if (rerun.command)
             commands.push(rerun.command);
-        if (pattern === null && rerun.timedOut) {
-            for (const failure of failures)
-                bump(counts, failureId(pkg, failure));
+        if (pattern === null && fileFailure === "timeout" && rerun.timedOut) {
+            for (const id of new Set(failures.map((item) => failureId(pkg, item))))
+                bump(counts, id);
             continue;
         }
         if (!rerun.report)
             continue;
+        const seen = new Set();
         for (const hit of rerun.report.failed) {
-            if (pattern === null && !hit.fileTimeout)
+            if (pattern === null && !(fileFailure === "timeout" ? hit.fileTimeout : hit.fileLoad))
                 continue;
             const id = failureId(pkg, hit);
             if (failures.some((item) => failureId(pkg, item) === id))
-                bump(counts, id);
+                seen.add(id);
         }
+        for (const id of seen)
+            bump(counts, id);
     }
     return wholeSuite;
 }
@@ -536,7 +596,7 @@ class NodeBatch {
             return {
                 report: null,
                 timedOut: false,
-                detail: waited.error || "test reporter returned nothing",
+                detail: waited.error || (selected.length > 0 ? `no requested test ran (${selected.join(", ")})` : "test reporter returned nothing"),
                 compileToken: null,
                 command: waited.command || "",
                 wholeSuite: false,
@@ -599,6 +659,11 @@ function isNodeTestFile(file) {
     const base = path.posix.basename(file);
     return /\.(test|spec)\.(ts|tsx|mts|js|mjs|cjs)$/.test(base) || /_test\.(ts|tsx|js|mjs)$/.test(base);
 }
+/** A node keep id may carry its file (`tests/gate.test.ts::zero stays shut`). node:test matches the title. */
+export function nodeTitle(id) {
+    const match = /^[^\s:][^:]*\.(?:[cm]?[jt]s|[jt]sx)::(.+)$/.exec(id);
+    return match ? match[1] : id;
+}
 function narrowNodeFiles(pkg, files, names, kind) {
     if (kind !== "node" || !names || names.length === 0)
         return files;
@@ -636,6 +701,18 @@ function childEnv(unset) {
         if (key === "NODE_TEST_CONTEXT" || key.startsWith("NODE_TEST_"))
             delete env[key];
     }
+    // This run may itself be a child of a suite that another Probatio run is mapping.
+    // That outer map is not this run's. Only the baseline sets a map, through runDiscoveredSuite.
+    delete env.PROBATIO_COVERAGE_MAP;
+    delete env.PROBATIO_PACKAGE_ROOT;
+    delete env.PROBATIO_CHILD_DIR;
+    if (env.NODE_OPTIONS) {
+        const kept = env.NODE_OPTIONS.split(/\s+/).filter((part) => part.length > 0 && !/child-lines\.mjs$/.test(part)).join(" ");
+        if (kept)
+            env.NODE_OPTIONS = kept;
+        else
+            delete env.NODE_OPTIONS;
+    }
     for (const key of unset)
         delete env[key];
     return env;
@@ -708,8 +785,8 @@ function loadMeta(dirs) {
     }
     return meta;
 }
-function loadRun(outDir, commit, agent) {
-    const file = path.join(outDir, "run.json");
+function loadRun(options, commit) {
+    const file = path.join(options.outDir, "run.json");
     if (existsSync(file)) {
         const stored = JSON.parse(readFileSync(file, "utf8"));
         if (stored.commit !== commit)
@@ -717,7 +794,24 @@ function loadRun(outDir, commit, agent) {
         return { id: stored.id };
     }
     const id = randomBytes(4).toString("hex");
-    writeFileSync(file, `${JSON.stringify({ id, commit, agent, started: new Date().toISOString() }, null, 2)}\n`);
+    const record = {
+        id,
+        commit,
+        agent: options.agent,
+        started: new Date().toISOString(),
+        package: options.packageDir,
+        patches: options.patchDirs,
+        out: options.outDir,
+        repo: options.repoDir,
+        workers: options.workers,
+        confirm: options.confirm,
+        testsDir: options.testsDir,
+        suiteTimeoutMs: options.suiteTimeoutMs,
+        testTimeoutMs: options.testTimeoutMs,
+        direction: options.direction,
+        suiteCommand: options.suiteCommand ?? null,
+    };
+    writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
     return { id };
 }
 async function createWorktrees(repo, packageDir, runId, commit, workers, outDir) {
@@ -725,6 +819,10 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
     const dirs = [];
     for (let index = 0; index < workers; index++) {
         const dir = path.join(tmpdir(), `probatio-${runId}-${index}`);
+        if (!probatioWorktreeDir(dir)) {
+            removeWorktrees(repo, dirs, outDir);
+            return { error: "worktree path is outside the probatio temp prefix" };
+        }
         rmSync(dir, { recursive: true, force: true });
         const added = git(repo, ["worktree", "add", "--detach", dir, commit]);
         if (added.status !== 0) {
@@ -735,8 +833,12 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
     }
     writeFileSync(path.join(outDir, "worktrees.json"), `${JSON.stringify(dirs)}\n`);
     const sources = nodeModuleSources(repo, packageDir);
+    const config = path.join(packageDir, CONFIG_FILE);
     for (const dir of dirs) {
         const pkgRoot = packageIn(dir, repo, packageDir);
+        // How to run the suite is not the code under test. An uncommitted .probatio.json still applies.
+        if (existsSync(config) && !existsSync(path.join(pkgRoot, CONFIG_FILE)))
+            copyFileSync(config, path.join(pkgRoot, CONFIG_FILE));
         for (const source of sources) {
             const dest = path.join(pkgRoot, source.rel);
             if (existsSync(dest))
@@ -750,15 +852,42 @@ async function createWorktrees(repo, packageDir, runId, commit, workers, outDir)
 function hidePaths(dirs, repo, packageDir, hide) {
     for (const dir of dirs) {
         const pkg = packageIn(dir, repo, packageDir);
+        const root = path.resolve(pkg);
         for (const rel of hide) {
-            if (!rel || path.isAbsolute(rel))
+            if (!rel || path.isAbsolute(rel) || rel.split(/[\\/]/).includes(".."))
+                continue;
+            const target = path.resolve(root, rel);
+            if (target !== root && !target.startsWith(root + path.sep))
                 continue;
-            rmSync(path.join(pkg, rel), { force: true });
+            rmSync(target, { force: true });
         }
     }
 }
+/** A worktree Probatio created: one directory under the OS temp dir, named probatio- plus hex and an index. */
+export function probatioWorktreeDir(dir) {
+    let resolved = path.resolve(dir);
+    try {
+        resolved = realpathSync(dir);
+    }
+    catch {
+        // The directory is created on the next line. The unresolved path is still checked.
+    }
+    const roots = new Set([path.resolve(tmpdir())]);
+    try {
+        roots.add(realpathSync(tmpdir()));
+    }
+    catch {
+        // tmpdir() itself is enough when realpath is unavailable.
+    }
+    const inside = [...roots].some((root) => resolved === root || resolved.startsWith(root + path.sep));
+    if (!inside)
+        return false;
+    return /^probatio-[0-9a-f]+-\d+$/.test(path.basename(resolved));
+}
 function removeWorktrees(repo, dirs, outDir) {
     for (const dir of dirs) {
+        if (!probatioWorktreeDir(dir))
+            continue;
         git(repo, ["worktree", "remove", "--force", dir]);
         rmSync(dir, { recursive: true, force: true });
     }
@@ -868,11 +997,12 @@ function readResult(outDir, id) {
     const file = resultPath(outDir, id);
     if (!existsSync(file))
         return null;
-    return JSON.parse(readFileSync(file, "utf8"));
+    return normalizeResult(JSON.parse(readFileSync(file, "utf8")));
 }
 function reportOf(results, context) {
     const count = (outcome) => results.filter((result) => result.outcome === outcome).length;
     const killed = count("killed");
+    const unviableCount = count("unviable");
     const survived = count("survived");
     const flaky = count("flaky");
     const timeouts = count("timeout");
@@ -886,7 +1016,7 @@ function reportOf(results, context) {
         return { id: result.id, file, line, ...(known?.op ? { op: known.op } : {}) };
     });
     const budgetHit = context.budgetHit || context.pendingLeft > 0;
-    const summary = campaignSummary({ noCoverage, survived, killed, flaky, timeouts, errors, finished: results.length });
+    const summary = campaignSummary({ noCoverage, survived, killed, unviable: unviableCount, flaky, timeouts, errors, finished: results.length });
     const notes = [];
     const uncovered = results.find((result) => result.outcome === "no coverage");
     if (uncovered?.next)
@@ -899,6 +1029,9 @@ function reportOf(results, context) {
         notes.push(resumeNext(context.notStarted));
     if (results.some((result) => result.wholeSuite))
         notes.push(WHOLE_SUITE_NEXT);
+    const broken = results.find((result) => (result.outcome === "error" || result.outcome === "build-failed") && result.error);
+    if (broken?.error)
+        notes.push(`${broken.id}: ${broken.error}`);
     if (notes.length === 0)
         notes.push("No survivor in this batch.");
     return {
@@ -909,6 +1042,8 @@ function reportOf(results, context) {
         commit: context.commit,
         runId: context.runId,
         killed,
+        unviable: unviableCount,
+        unviableIds: results.filter((result) => result.outcome === "unviable").slice(0, 10).map((result) => result.id),
         survived,
         flaky,
         timeouts,
@@ -968,6 +1103,8 @@ function failReport(outDir, runId, commit, error, baselineFailed, next, suiteCom
         commit,
         runId,
         killed: 0,
+        unviable: 0,
+        unviableIds: [],
         survived: 0,
         flaky: 0,
         timeouts: 0,
@@ -1132,10 +1269,19 @@ function failureId(pkg, failure) {
         return BARE_SUITE.has(failure.name) ? `::${failure.name}` : failure.name;
     if (!testFileOnDisk(pkg, failure.file))
         return failure.name;
-    const rel = path.relative(pkg, failure.file);
+    // macOS temp dirs are /var and /private/var. A report can name either, so compare real paths.
+    const rel = path.relative(realOrSame(pkg), realOrSame(path.resolve(pkg, failure.file)));
     const file = !rel || rel.startsWith("..") ? path.basename(failure.file) : rel.split(path.sep).join("/");
     return `${file}::${failure.name}`;
 }
+function realOrSame(file) {
+    try {
+        return realpathSync(file);
+    }
+    catch {
+        return file;
+    }
+}
 function testFileOnDisk(pkg, file) {
     if (path.isAbsolute(file))
         return existsSync(file);
@@ -1156,13 +1302,27 @@ function testArg(pkg, file, testsDir) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function baselineReportError(detail) {
+function missingToolFrom(detail, command) {
+    const spawnMiss = /spawn ([^\s]+) ENOENT/.exec(detail);
+    if (spawnMiss)
+        return path.basename(spawnMiss[1]);
+    const shellMiss = /(?:^|\s)([A-Za-z0-9_./+-]+): (?:command not found|not found)\b/.exec(detail);
+    if (shellMiss)
+        return path.basename(shellMiss[1]);
+    if (/No such file or directory|ENOENT/.test(detail)) {
+        const bin = command.trim().split(/\s+/)[0];
+        if (bin)
+            return path.basename(bin);
+    }
+    return null;
+}
+function baselineReportError(detail, command = "") {
+    const tool = missingToolFrom(detail, command);
     const line = detail.trim();
     // The first line of a Python or Node crash is a stack fragment. The summary
     // states the limit and does not carry that fragment.
-    if (!line || isStackFragment(line))
-        return "baseline suite did not return a test report";
-    return `baseline suite did not return a test report (${line})`;
+    const base = !line || isStackFragment(line) ? "baseline suite did not return a test report" : `baseline suite did not return a test report (${line})`;
+    return tool ? `missing tool: ${tool}. ${base}` : base;
 }
 function isStackFragment(line) {
     return line.startsWith("Traceback") || /^\s+at \S/.test(line) || /File ".+", line \d+/.test(line);

package/dist/mutate/rust-coverage.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { exportLlvmProfile, llvmToolsPresent } from "./coverage-map.js";
 /**
  * One instrumented test binary, then one profile per test name.
  * A single cargo test profile does not say which test hit the line.
@@ -9,9 +10,7 @@ export function writeRustCoverage(pkg, testNames, dest) {
     const names = [...new Set(testNames.map((name) => name.trim()).filter((name) => name.length > 0 && !/\s/.test(name)))];
     if (names.length === 0)
         return { ok: false, detail: "rust coverage: no test names" };
-    const llvmCov = findTool("llvm-cov");
-    const llvmProf = findTool("llvm-profdata");
-    if (!llvmCov || !llvmProf)
+    if (!llvmToolsPresent())
         return { ok: false, detail: "rust coverage: llvm tool missing" };
     const env = { ...process.env, RUSTFLAGS: "-C instrument-coverage", CARGO_INCREMENTAL: "0" };
     const built = spawnSync("cargo", ["test", "--no-run", "--message-format=json"], {
@@ -43,11 +42,8 @@ export function writeRustCoverage(pkg, testNames, dest) {
             if (!new RegExp(`^test ${escapeRegExp(name)} \\.\\.\\. ok`, "m").test(`${ran.stdout}\n${ran.stderr}`))
                 continue;
             const merged = path.join(work, `${safe(name)}-${safe(path.basename(exe))}.profdata`);
-            const merge = spawnSync(llvmProf, ["merge", "-sparse", "-o", merged, raw], { encoding: "utf8" });
-            if (merge.status !== 0)
-                continue;
-            const exported = spawnSync(llvmCov, ["export", exe, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-            if (exported.status !== 0)
+            const exported = exportLlvmProfile(exe, [raw], merged);
+            if (!exported.ok)
                 continue;
             for (const hit of llvmHits(exported.stdout, pkg))
                 addHit(files, hit.file, hit.line, name);
@@ -136,17 +132,6 @@ function addHit(files, file, line, test) {
     lines[key] = names;
     files[file] = lines;
 }
-function findTool(name) {
-    const fromXcrun = spawnSync("xcrun", ["--find", name], { encoding: "utf8" });
-    const xcrunPath = fromXcrun.stdout?.trim() ?? "";
-    if (fromXcrun.status === 0 && xcrunPath && existsSync(xcrunPath))
-        return xcrunPath;
-    const which = spawnSync("sh", ["-c", `command -v ${name}`], { encoding: "utf8" });
-    const found = which.stdout?.trim() ?? "";
-    if (which.status === 0 && found)
-        return found;
-    return null;
-}
 function safe(value) {
     return value.replace(/[^A-Za-z0-9._-]+/g, "_");
 }

package/dist/mutate/sealed.js

@@ -1,4 +1,6 @@
-import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
 /** The label stays in its own file. The run report must not repeat these three values. */
 export function readSealedLabel(file) {
     let text = "";
@@ -18,8 +20,99 @@ export function readSealedLabel(file) {
 export function labelLeaked(body, label) {
     return body.includes(label.bugId) || body.includes(label.issueId) || body.includes(label.expectedFail);
 }
+/** The envelope can be clean while a result file on disk still repeats the label. */
+export function sealedTreeLeaked(dir, label) {
+    const visit = (current) => {
+        let names;
+        try {
+            names = readdirSync(current);
+        }
+        catch {
+            return false;
+        }
+        for (const name of names) {
+            const full = path.join(current, name);
+            let info;
+            try {
+                info = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (info.isDirectory()) {
+                if (visit(full))
+                    return true;
+                continue;
+            }
+            if (!info.isFile() || info.size > 2_000_000)
+                continue;
+            try {
+                if (labelLeaked(readFileSync(full, "utf8"), label))
+                    return true;
+            }
+            catch {
+                // A binary artifact is not a report.
+            }
+        }
+        return false;
+    };
+    return visit(dir);
+}
 export const LABEL_LEAK_SUMMARY = "The label was copied into the report.";
 function field(text, key) {
     const match = text.match(new RegExp(`^${key}=(.*)$`, "m"));
     return match?.[1]?.trim() ?? "";
 }
+/**
+ * A sealed run hides the revealing test, but a fix commit often edits an older test too.
+ * A kill by that edited test is the fix's own test, not an older test that caught the bug.
+ * Returns the edited test files that killed, and whether any kill came from a test the fix left alone.
+ */
+export function fixEditedKillers(repo, packageDir, commit, hide, kills) {
+    if (kills.length === 0)
+        return { files: [], olderTestCatch: false };
+    const diff = spawnSync("git", ["-C", repo, "diff", "--name-only", `${commit}^`, commit], { encoding: "utf8" });
+    // No parent, or git failed: nothing is known to be edited, so every kill stays an older-test catch.
+    if (diff.status !== 0)
+        return { files: [], olderTestCatch: true };
+    const hidden = new Set(hide.map((rel) => rel.split(path.sep).join("/")));
+    const edited = diff.stdout
+        .split("\n")
+        .filter((rel) => rel.length > 0)
+        .map((rel) => ({ repoRel: rel, pkgRel: path.relative(packageDir, path.join(repo, rel)).split(path.sep).join("/") }))
+        .filter((item) => !item.pkgRel.startsWith("..") && !hidden.has(item.pkgRel));
+    const text = new Map();
+    const contents = (repoRel) => {
+        if (!text.has(repoRel)) {
+            const shown = spawnSync("git", ["-C", repo, "show", `${commit}:${repoRel}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+            text.set(repoRel, shown.status === 0 ? shown.stdout : "");
+        }
+        return text.get(repoRel) ?? "";
+    };
+    const fileFor = (id) => edited.find((item) => killerInFile(id, item.pkgRel, () => contents(item.repoRel)));
+    const files = new Set();
+    let olderTestCatch = false;
+    for (const kill of kills) {
+        const owners = kill.killedBy.map(fileFor);
+        for (const owner of owners)
+            if (owner)
+                files.add(owner.pkgRel);
+        if (owners.some((owner) => !owner))
+            olderTestCatch = true;
+    }
+    return { files: [...files].sort(), olderTestCatch };
+}
+/** True when a kill id names this file, its class, or a test written in it. */
+function killerInFile(id, rel, read) {
+    if (id.includes(rel) || id.startsWith(`${path.posix.basename(rel)}::`))
+        return true;
+    const stem = path.posix.basename(rel).replace(/\.[^.]+$/, "");
+    // JUnit `pkg.ClassTest.method` or `ClassTest#method`, Go and Rust paths.
+    if (stem.length > 0 && id.split(/[.#:/]+/).includes(stem))
+        return true;
+    const leaf = id.split(/::|#/).pop()?.split(/\.(?=[^.]+$)/).pop()?.replace(/\[.*\]$/, "").trim() ?? "";
+    if (leaf.length < 4)
+        return false;
+    const body = read();
+    return [`"${leaf}"`, `'${leaf}'`, `\`${leaf}\``, `${leaf}(`, `def ${leaf}`, `func ${leaf}`, `fn ${leaf}`].some((needle) => body.includes(needle));
+}

package/dist/mutate/suite-decision.js

@@ -1,6 +1,7 @@
 /** Pure suite decisions. The process spawn stays in the runner. */
 export const UNKNOWN_NEXT = "The suite command is unknown. Pass --suite-command with the command that runs this package's tests.";
 export const TIMEOUT_NEXT = "Timed out. The mutant ran longer than the baseline allows.";
+export const UNVIABLE_NEXT = "The mutant did not build. No test saw it, so it is not a kill and not a gap. No test is needed.";
 export const WHOLE_SUITE_NEXT = "The suite command cannot take a test name, so the whole suite ran.";
 export const TIMEOUT_MULTIPLE = 5;
 /** cargo-mutants uses 20s. A fixture can pass a smaller positive floor. */
@@ -22,7 +23,7 @@ export function leadSummary(noCoverage, survivors, survivorWord, rest) {
     return `${noCoverage} no coverage, ${survivors} ${survivorWord}, ${rest}`;
 }
 export function campaignSummary(counts) {
-    return leadSummary(counts.noCoverage, counts.survived, "survived", `${counts.killed} killed, ${counts.flaky} flaky, ${counts.timeouts} timed out, ${counts.errors} errored, of ${counts.finished} finished.`);
+    return leadSummary(counts.noCoverage, counts.survived, "survived", `${counts.killed} killed, ${counts.unviable ? `${counts.unviable} did not build, ` : ""}${counts.flaky} flaky, ${counts.timeouts} timed out, ${counts.errors} errored, of ${counts.finished} finished.`);
 }
 export function timeoutLimitMs(baselineMs, multiple, floorMs) {
     const floor = Math.max(1, floorMs);