probatio 0.1.0 → 0.1.3

package/dist/mutate/run.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,7 +13,7 @@ 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 { commandSuite, discoverSuite, runDiscoveredSuite, sourceCandidates } from "./suites.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));
 export function parseReport(stdout) {
@@ -41,7 +41,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);
@@ -89,34 +89,61 @@ export async function runMutants(options) {
         budgetStarted = Date.now();
         const worker = async (worktree) => {
             const treePkg = packageIn(worktree, repo, packageDir);
-            for (;;) {
-                if (startedMutants > 0 && overBudget()) {
-                    budgetHit = true;
-                    return;
-                }
-                const patch = queue.shift();
-                if (!patch)
-                    return;
-                if (startedMutants > 0 && overBudget()) {
-                    queue.unshift(patch);
-                    budgetHit = true;
-                    return;
-                }
-                const id = path.basename(patch, ".patch");
-                const raw = readFileSync(patch, "utf8");
-                const prior = history.get(id);
-                if (prior && reusable(prior, raw, treePkg)) {
+            let batch = null;
+            const dropBatch = () => {
+                batch?.stop();
+                batch = null;
+            };
+            try {
+                for (;;) {
+                    if (startedMutants > 0 && overBudget()) {
+                        budgetHit = true;
+                        return;
+                    }
+                    const patch = queue.shift();
+                    if (!patch)
+                        return;
+                    if (startedMutants > 0 && overBudget()) {
+                        queue.unshift(patch);
+                        budgetHit = true;
+                        return;
+                    }
+                    const id = path.basename(patch, ".patch");
+                    const raw = readFileSync(patch, "utf8");
+                    const prior = history.get(id);
+                    if (prior && reusable(prior, raw, treePkg)) {
+                        startedMutants += 1;
+                        const reused = reusedResult(prior, commit, run.id, options.agent);
+                        writeResult(options.outDir, reused);
+                        progress(`reused ${id}`);
+                        continue;
+                    }
                     startedMutants += 1;
-                    const reused = reusedResult(prior, commit, run.id, options.agent);
-                    writeResult(options.outDir, reused);
-                    progress(`reused ${id}`);
-                    continue;
+                    progress(`${id} start`);
+                    const plan = batchPlan(raw, prep, options);
+                    if (plan) {
+                        if (!batch || batch.dead) {
+                            dropBatch();
+                            try {
+                                batch = await NodeBatch.start(treePkg, options, options.outDir);
+                            }
+                            catch {
+                                batch = null;
+                            }
+                        }
+                    }
+                    const launch = plan && batch
+                        ? (pkg, files, names, timeoutMs) => batch.run(pkg, files, names, timeoutMs, id, options.outDir)
+                        : undefined;
+                    const result = await runOne(worktree, treePkg, patch, options, commit, run.id, prep, launch);
+                    writeResult(options.outDir, result);
+                    if (batch && (batch.dead || result.error === "suite process crashed"))
+                        dropBatch();
+                    progress(`${id} ${result.outcome}`);
                 }
-                startedMutants += 1;
-                progress(`${id} start`);
-                const result = await runOne(worktree, treePkg, patch, options, commit, run.id, prep);
-                writeResult(options.outDir, result);
-                progress(`${id} ${result.outcome}`);
+            }
+            finally {
+                dropBatch();
             }
         };
         await Promise.all(worktrees.dirs.map((dir) => worker(dir)));
@@ -184,7 +211,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);
@@ -197,6 +224,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)) {
@@ -217,18 +248,19 @@ async function prepare(pkg, options, progress) {
     const affectedMap = options.affected ? affectedTests(pkg, { testsDir: options.testsDir }) : null;
     return { ok: true, tests, affectedMap, baselineMs, spec, coverage: readCoverageMap(mapPath) };
 }
-async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
+async function runOne(worktree, pkg, patchPath, options, commit, runId, prep, launch) {
     const id = path.basename(patchPath, ".patch");
     const started = Date.now();
     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: "",
@@ -277,17 +309,31 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
         // node --test loads every file it is given, so a name pattern still pays for the other files.
         const selected = narrowNodeFiles(pkg, selectTests(files, prep.tests, prep.affectedMap), names, prep.spec.kind);
         const commands = [];
-        const main = await runSuite(pkg, selected, options, null, names && names.length > 0 ? names : null, prep.spec, limit, forceWhole, null, null);
+        const named = names && names.length > 0 ? names : null;
+        const main = launch
+            ? await launch(pkg, selected, named, limit)
+            : await runSuite(pkg, selected, options, null, named, prep.spec, limit, forceWhole, null, null);
         if (main.command)
             commands.push(main.command);
+        if (main.crashed) {
+            return finishMutant({ ...base(), direction, outcome: "error", error: "suite process crashed" }, pkg, commands.join(" | "), false, main.selectedTests);
+        }
         if (main.timedOut) {
             return finishMutant({ ...base(), direction, outcome: "timeout", error: "suite timed out", next: TIMEOUT_NEXT }, pkg, commands.join(" | "), main.wholeSuite || forceWhole, main.selectedTests);
         }
         // 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(" | ") };
+        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(" | ") };
+        }
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
         if (main.report.failed.length === 0)
@@ -364,19 +410,22 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
         if (rerun.command)
             commands.push(rerun.command);
         if (pattern === null && rerun.timedOut) {
-            for (const failure of failures)
-                bump(counts, failureId(pkg, failure));
+            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)
                 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;
 }
@@ -404,6 +453,164 @@ async function runSuite(pkg, files, options, pattern, names, spec, timeoutMs, fo
         selectedTests: result.selectedTests,
     };
 }
+function batchPlan(raw, prep, options) {
+    if (options.workers !== 1 || prep.spec.kind !== "node")
+        return null;
+    if (!prep.coverage || Object.keys(prep.coverage.files).length === 0)
+        return null;
+    const edited = changedLines(raw);
+    const files = filesInDiff(raw);
+    if (new Set(files.map((item) => item.file)).size !== 1)
+        return null;
+    const picked = selectionFor(prep.coverage, edited.length > 0 ? edited : files);
+    if (picked.state !== "covered")
+        return null;
+    const names = picked.tests.filter((name) => name !== WHOLE_PROGRAM_TEST && name.length > 0);
+    if (names.length === 0)
+        return null;
+    return { names };
+}
+/** Covered node mutants of one file share this process. A crash sets dead and the next mutant starts another. */
+class NodeBatch {
+    pid;
+    dead = false;
+    testTimeoutMs;
+    proc;
+    constructor(proc, pid, testTimeoutMs) {
+        this.proc = proc;
+        this.pid = pid;
+        this.testTimeoutMs = testTimeoutMs;
+        proc.on("close", () => {
+            this.dead = true;
+        });
+    }
+    static async start(pkg, options, outDir) {
+        const dir = path.join(outDir, "batch");
+        mkdirSync(dir, { recursive: true });
+        const ready = path.join(dir, `ready-${process.pid}-${Date.now()}.json`);
+        const gen = path.join(dir, `gen-${process.pid}-${Date.now()}.txt`);
+        writeFileSync(gen, "0\n");
+        const script = fileURLToPath(new URL("./node-batch.mjs", import.meta.url));
+        const env = childEnv(options.unset);
+        env.PB_READY = ready;
+        env.PB_GEN = gen;
+        env.PB_ROOT = pkg;
+        const proc = spawn(process.execPath, [script], { cwd: pkg, env, stdio: ["pipe", "ignore", "pipe"] });
+        const started = Date.now();
+        while (!existsSync(ready)) {
+            if (proc.exitCode !== null)
+                throw new Error("batch process exited before ready");
+            if (Date.now() - started > 10_000) {
+                proc.kill("SIGKILL");
+                throw new Error("batch process did not start");
+            }
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+        const body = JSON.parse(readFileSync(ready, "utf8"));
+        return new NodeBatch(proc, body.pid || proc.pid || 0, options.testTimeoutMs);
+    }
+    stop() {
+        this.dead = true;
+        try {
+            this.proc.stdin?.end();
+        }
+        catch {
+            // The pipe is already closed.
+        }
+        try {
+            if (this.proc.pid)
+                process.kill(this.proc.pid, "SIGTERM");
+        }
+        catch {
+            // The process has already exited.
+        }
+    }
+    async run(pkg, files, names, timeoutMs, id, outDir) {
+        const selected = names ?? [];
+        const replyFile = path.join(outDir, "batch", `${id}.reply.json`);
+        rmSync(replyFile, { force: true });
+        appendFileSync(path.join(outDir, "batch-processes.jsonl"), `${JSON.stringify({ id, pid: this.pid })}\n`);
+        const job = { id, root: pkg, tests: files, names: selected, timeoutMs, testTimeoutMs: nodeTestTimeoutMs(pkg, files, this.testTimeoutMs, timeoutMs), replyFile };
+        try {
+            this.proc.stdin?.write(`${JSON.stringify(job)}\n`);
+        }
+        catch {
+            this.dead = true;
+            return crashedCall(selected);
+        }
+        const waited = await waitForReply(replyFile, this.proc, timeoutMs);
+        if (waited === "timeout") {
+            this.dead = true;
+            this.stop();
+            return { report: null, timedOut: true, detail: "suite timed out", compileToken: null, command: "", wholeSuite: false, selectedTests: selected };
+        }
+        if (!waited)
+            return crashedCall(selected);
+        const failed = waited.failed ?? [];
+        const seen = waited.names ?? [];
+        if (seen.length === 0 && failed.length === 0) {
+            return {
+                report: null,
+                timedOut: false,
+                detail: waited.error || "test reporter returned nothing",
+                compileToken: null,
+                command: waited.command || "",
+                wholeSuite: false,
+                selectedTests: selected,
+            };
+        }
+        return {
+            report: { tests: Math.max(seen.length, failed.length), pass: Math.max(0, seen.length - failed.length), fail: failed.length, failed, names: seen.length > 0 ? seen : selected },
+            timedOut: false,
+            detail: "",
+            compileToken: null,
+            command: waited.command || "",
+            wholeSuite: false,
+            selectedTests: selected,
+        };
+    }
+}
+function crashedCall(selected) {
+    return { report: null, timedOut: false, detail: "suite process crashed", compileToken: null, command: "", wholeSuite: false, selectedTests: selected, crashed: true };
+}
+function waitForReply(file, proc, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearInterval(poll);
+            proc.removeListener("close", onClose);
+            resolve(value);
+        };
+        const read = () => {
+            try {
+                return JSON.parse(readFileSync(file, "utf8"));
+            }
+            catch {
+                return null;
+            }
+        };
+        const onClose = () => {
+            const reply = existsSync(file) ? read() : null;
+            finish(reply);
+        };
+        const timer = setTimeout(() => finish("timeout"), timeoutMs);
+        const poll = setInterval(() => {
+            if (!existsSync(file))
+                return;
+            const reply = read();
+            if (reply)
+                finish(reply);
+        }, 20);
+        if (proc.exitCode !== null || proc.signalCode !== null)
+            onClose();
+        else
+            proc.once("close", onClose);
+    });
+}
 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);
@@ -517,8 +724,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)
@@ -526,7 +733,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) {
@@ -534,6 +758,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) {
@@ -559,15 +787,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 });
     }
@@ -708,6 +963,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 {
@@ -965,13 +1223,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,5 @@
-import { readFileSync } from "node:fs";
+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,6 +19,44 @@ 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"));

package/dist/mutate/suite-decision.js

@@ -30,7 +30,7 @@ export function timeoutLimitMs(baselineMs, multiple, floorMs) {
     return Math.max(floor, scaled);
 }
 /** Kinds that collect a per-line map on the baseline. Other kinds pay the whole suite. */
-const LINE_MAP_KINDS = new Set(["node", "pytest", "c", "go", "maven", "cargo", "dotnet"]);
+const LINE_MAP_KINDS = new Set(["node", "pytest", "c", "go", "maven", "cargo", "dotnet", "mocha"]);
 /** A baseline this long, with no line map, is too expensive to repeat for a large batch. */
 export const SLOW_BASELINE_MS = 5_000;
 /** Pending mutants above this count, on a slow unmapped suite, are not started. */