probatio 0.2.0 → 0.5.0

package/dist/mutate/generate.js

@@ -1,153 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { mutantId, makeRng, shuffle } from "./ids.js";
-import { findInSource, isGeneratedSource } from "./find.js";
-import { forwardDiff } from "./patch.js";
-export function generateMutants(options) {
-    const started = Date.now();
-    const limit = options.maxMinutes;
-    const over = () => limit != null && Date.now() - started >= limit * 60_000;
-    const sourceDefault = options.workingTree ? "working-tree" : "commit";
-    if (over())
-        return { mutants: [], violations: [], filesVisited: 0, budgetHit: true, source: sourceDefault };
-    const srcRoot = path.resolve(options.packageDir, options.srcDir);
-    const walked = walkSources(srcRoot, over);
-    const files = walked.files.filter((file) => !options.skipFiles.includes(path.basename(file)));
-    const rng = makeRng(options.seed);
-    const violations = [];
-    const chosen = [];
-    let filesVisited = 0;
-    let budgetHit = walked.stopped;
-    let source = sourceDefault;
-    for (const file of files) {
-        if (over()) {
-            budgetHit = true;
-            break;
-        }
-        filesVisited += 1;
-        const loaded = fileText(options.packageDir, file, options);
-        if ("error" in loaded)
-            return { mutants: [], violations: [], filesVisited, budgetHit, source: "commit", error: loaded.error };
-        source = loaded.source;
-        const text = loaded.text;
-        const rel = posix(path.relative(options.packageDir, file));
-        const found = findInSource(rel, text);
-        violations.push(...found.violations);
-        const ordered = shuffle(found.points, rng);
-        const slice = options.perFile === null ? ordered.slice(options.skip) : ordered.slice(options.skip, options.skip + options.perFile);
-        for (const point of slice)
-            chosen.push({ rel, text, point });
-    }
-    if (violations.length > 0)
-        return { mutants: [], violations, filesVisited, budgetHit, source };
-    const capped = options.maxMutants === null ? chosen : chosen.slice(0, options.maxMutants);
-    const packageReal = real(options.packageDir);
-    const patchRoot = gitRoot(packageReal);
-    const prefix = patchRoot ? path.relative(patchRoot, packageReal) : "";
-    const mutantsDir = path.join(options.outDir, "mutants");
-    rmSync(mutantsDir, { recursive: true, force: true });
-    mkdirSync(mutantsDir, { recursive: true });
-    const mutants = [];
-    for (const item of capped) {
-        const id = mutantId(item.rel, item.point.start, item.point.end, item.point.op);
-        const mutated = item.text.slice(0, item.point.start) + item.point.replacement + item.text.slice(item.point.end);
-        const label = prefix && !prefix.startsWith("..") ? posix(path.join(prefix, item.rel)) : item.rel;
-        const diff = forwardDiff(label, item.text, mutated);
-        if (!diff)
-            continue;
-        const patch = `${id}.patch`;
-        writeFileSync(path.join(mutantsDir, patch), diff);
-        mutants.push({ id, file: item.rel, line: item.point.line, op: item.point.op, patch });
-    }
-    writeFileSync(path.join(mutantsDir, "mutants.json"), `${JSON.stringify({ schemaVersion: 1, seed: options.seed, mutants }, null, 2)}\n`);
-    return { mutants, violations, filesVisited, budgetHit, source };
-}
-function fileText(packageDir, absFile, options) {
-    if (options.workingTree)
-        return { text: readFileSync(absFile, "utf8"), source: "working-tree" };
-    const root = gitRoot(packageDir);
-    if (!root)
-        return { text: readFileSync(absFile, "utf8"), source: "working-tree" };
-    const rel = posix(path.relative(root, real(absFile)));
-    const commit = options.commit && options.commit.length > 0 ? options.commit : "HEAD";
-    const shown = spawnSync("git", ["-C", root, "show", `${commit}:${rel}`], { encoding: "utf8" });
-    if (shown.status !== 0) {
-        const shownRel = posix(path.relative(packageDir, absFile));
-        return { error: `${shownRel} is not in ${commit}. Pass --working-tree to read the checkout.` };
-    }
-    return { text: shown.stdout, source: "commit" };
-}
-function walkSources(dir, over) {
-    if (!statExists(dir))
-        return { files: [], stopped: false };
-    const out = [];
-    let stopped = false;
-    const walk = (current) => {
-        if (over()) {
-            stopped = true;
-            return;
-        }
-        let entries;
-        try {
-            entries = readdirSync(current).sort();
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (over()) {
-                stopped = true;
-                return;
-            }
-            if (entry === "node_modules" || entry === ".git")
-                continue;
-            const full = path.join(current, entry);
-            let info;
-            try {
-                info = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (info.isDirectory()) {
-                walk(full);
-                if (stopped)
-                    return;
-            }
-            else if (isSource(entry))
-                out.push(full);
-        }
-    };
-    walk(dir);
-    return { files: out, stopped };
-}
-function isSource(name) {
-    return isGeneratedSource(name);
-}
-function statExists(file) {
-    try {
-        statSync(file);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function gitRoot(cwd) {
-    const result = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
-    if (result.status !== 0)
-        return null;
-    return real(result.stdout.trim());
-}
-function real(file) {
-    try {
-        return realpathSync(file);
-    }
-    catch {
-        return path.resolve(file);
-    }
-}
-function posix(file) {
-    return file.split(path.sep).join("/");
-}

package/dist/mutate/go-coverage.js

@@ -1,100 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-/** Blocks in a Go cover profile whose count is above zero. */
-export function parseCoverProfile(text, modulePath) {
-    const hits = [];
-    const prefix = modulePath ? `${modulePath}/` : "";
-    for (const raw of text.split("\n")) {
-        const line = raw.trim();
-        if (!line || line.startsWith("mode:"))
-            continue;
-        const match = /^(.+):(\d+)\.\d+,(\d+)\.\d+\s+\d+\s+(\d+)$/.exec(line);
-        if (!match)
-            continue;
-        if (Number(match[4]) <= 0)
-            continue;
-        let file = match[1];
-        if (prefix && file.startsWith(prefix))
-            file = file.slice(prefix.length);
-        file = file.split("\\").join("/");
-        const start = Number(match[2]);
-        const end = Number(match[3]);
-        for (let number = start; number <= end; number++)
-            hits.push({ file, line: number });
-    }
-    return hits;
-}
-/**
- * One compiled test binary per package, then one profile per test name.
- * A stock cover profile does not name the test, so each test gets its own.
- */
-export function writeGoCoverage(pkg, testNames, dest) {
-    const wanted = new Set(testNames.filter((name) => name.length > 0 && !name.includes("/")));
-    if (wanted.size === 0)
-        return { ok: false, detail: "go coverage: no test names" };
-    const mod = run("go", ["list", "-m"], pkg);
-    if (mod.status !== 0)
-        return { ok: false, detail: clip(mod.stderr || mod.stdout || mod.error?.message || "go list -m failed") };
-    const modulePath = mod.stdout.trim().split("\n")[0]?.trim() ?? "";
-    const listed = run("go", ["list", "-f", "{{.ImportPath}}\t{{.Dir}}\t{{len .TestGoFiles}}\t{{len .XTestGoFiles}}", "./..."], pkg);
-    if (listed.status !== 0)
-        return { ok: false, detail: clip(listed.stderr || listed.stdout || listed.error?.message || "go list failed") };
-    const work = path.join(path.dirname(dest), "go-cover");
-    mkdirSync(work, { recursive: true });
-    const files = {};
-    const packages = listed.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-    for (const row of packages) {
-        const [importPath, dir, testFiles, xTestFiles] = row.split("\t");
-        if (!importPath || !dir)
-            continue;
-        if (Number(testFiles ?? "0") + Number(xTestFiles ?? "0") <= 0)
-            continue;
-        const bin = path.join(work, `${safe(importPath)}.test`);
-        const compiled = run("go", ["test", "-c", "-covermode=set", "-o", bin, importPath], pkg);
-        if (compiled.status !== 0 || compiled.error)
-            continue;
-        const listedTests = run(bin, ["-test.list", "."], dir);
-        if (listedTests.status !== 0)
-            continue;
-        for (const name of listedTests.stdout.split("\n").map((item) => item.trim()).filter((item) => wanted.has(item))) {
-            const profile = path.join(work, `${safe(importPath)}-${safe(name)}.out`);
-            run(bin, ["-test.run", `^${escapeRegExp(name)}$`, "-test.coverprofile", profile], dir);
-            let text = "";
-            try {
-                text = readFileSync(profile, "utf8");
-            }
-            catch {
-                continue;
-            }
-            for (const hit of parseCoverProfile(text, modulePath))
-                addHit(files, hit.file, hit.line, name);
-        }
-    }
-    if (Object.keys(files).length === 0)
-        return { ok: false, detail: "go coverage: no covered lines" };
-    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
-    return { ok: true, detail: `${Object.keys(files).length} files` };
-}
-function addHit(files, file, line, test) {
-    const lines = files[file] ?? {};
-    const key = String(line);
-    const names = lines[key] ?? [];
-    if (!names.includes(test))
-        names.push(test);
-    lines[key] = names;
-    files[file] = lines;
-}
-function safe(value) {
-    return value.replace(/[^A-Za-z0-9._-]+/g, "_");
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function run(bin, args, cwd) {
-    return spawnSync(bin, args, { cwd, encoding: "utf8", timeout: 120_000 });
-}
-function clip(text) {
-    const line = text.trim().split("\n").find((item) => item.trim()) ?? "go coverage failed";
-    return line.slice(0, 240);
-}

package/dist/mutate/ids.js

@@ -1,22 +0,0 @@
-import { createHash } from "node:crypto";
-/** Stable across reruns: hash of the package-relative file, the span, and the operator. */
-export function mutantId(file, start, end, op) {
-    const hex = createHash("sha256").update(`${file}\0${start}\0${end}\0${op}`).digest("hex").slice(0, 12);
-    return `m${hex}`;
-}
-/** Same sequence for the same seed. Not the Auspex experiment's floating-point shuffle. */
-export function makeRng(seed) {
-    let state = seed >>> 0;
-    return () => {
-        state = (Math.imul(state, 1103515245) + 12345) >>> 0;
-        return state / 4294967296;
-    };
-}
-export function shuffle(items, rng) {
-    const out = [...items];
-    for (let index = out.length - 1; index > 0; index--) {
-        const swap = Math.floor(rng() * (index + 1));
-        [out[index], out[swap]] = [out[swap], out[index]];
-    }
-    return out;
-}

package/dist/mutate/java-coverage.js

@@ -1,217 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const JACOCO = "0.8.15";
-const ASM = "9.10.1";
-const RUNNER = fileURLToPath(new URL("./probatio-jacoco-run.java", import.meta.url));
-/**
- * One JVM, one JaCoCo dump per Surefire test method.
- * The default jacoco.exec file does not name the test.
- */
-export function writeJavaCoverage(pkg, testNames, dest) {
-    const tests = testNames.map(junitMethod).filter((name) => name !== null);
-    if (tests.length === 0)
-        return { ok: false, detail: "java coverage: no class.method test names" };
-    const classDirs = findClassDirs(pkg);
-    if (classDirs.length === 0)
-        return { ok: false, detail: "java coverage: no target/classes" };
-    const work = path.join(path.dirname(dest), "java-cover");
-    mkdirSync(work, { recursive: true });
-    const jars = resolveJars(pkg, work);
-    if ("error" in jars)
-        return { ok: false, detail: jars.error };
-    const source = path.join(work, "ProbatioJacocoRun.java");
-    writeFileSync(source, readFileSync(RUNNER));
-    const compileCp = [jars.agent, jars.junit, jars.core, jars.asm, jars.asmCommons, jars.asmTree].join(path.delimiter);
-    const compiled = run(javaTool("javac"), ["-encoding", "UTF-8", "-cp", compileCp, "-d", work, source], pkg);
-    if (compiled.status !== 0)
-        return { ok: false, detail: clip(compiled.stderr || compiled.stdout || compiled.error?.message || "javac failed") };
-    const testsFile = path.join(work, "tests.txt");
-    writeFileSync(testsFile, `${tests.join("\n")}\n`);
-    const projectCp = buildClasspath(pkg, work);
-    if ("error" in projectCp)
-        return { ok: false, detail: projectCp.error };
-    // Surefire brings the platform launcher. A project's test classpath often has the Jupiter engine and not the launcher.
-    const launcher = platformLauncherJar(pkg, work, projectCp.cp);
-    if ("error" in launcher)
-        return { ok: false, detail: launcher.error };
-    // Our asm and JaCoCo must win over a project that still ships an older asm. That older reader rejects Java 27 class files.
-    const cp = [work, jars.core, jars.asm, jars.asmCommons, jars.asmTree, jars.junit, launcher.jar, ...classDirs, ...testClassDirs(pkg), projectCp.cp].filter(Boolean).join(path.delimiter);
-    const dump = path.join(work, "hits.txt");
-    const ran = run(javaTool("java"), [`-javaagent:${jars.agent}=output=none,excludes=ProbatioJacocoRun:org.junit.*:org.apiguardian.*:org.opentest4j.*`, "-cp", cp, "ProbatioJacocoRun", classDirs.join(path.delimiter), testsFile, dump, pkg], pkg, 900_000);
-    if (ran.error && ran.error.code === "ETIMEDOUT") {
-        return { ok: false, detail: "java coverage: timed out" };
-    }
-    if (ran.status !== 0 || !existsSync(dump)) {
-        return { ok: false, detail: clip(ran.stderr || ran.stdout || ran.error?.message || "java coverage runner failed") };
-    }
-    const files = hitsToMap(readFileSync(dump, "utf8"));
-    if (Object.keys(files).length === 0)
-        return { ok: false, detail: "java coverage: no covered lines" };
-    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
-    return { ok: true, detail: `${Object.keys(files).length} files` };
-}
-export function hitsToMap(text) {
-    const files = {};
-    for (const raw of text.split("\n")) {
-        const line = raw.trim();
-        if (!line.startsWith("HIT "))
-            continue;
-        const parts = line.slice(4).split(" ");
-        if (parts.length < 3)
-            continue;
-        const test = parts.pop() ?? "";
-        const number = parts.pop() ?? "";
-        const file = parts.join(" ");
-        if (!file || !/^\d+$/.test(number) || !test)
-            continue;
-        const lines = files[file] ?? {};
-        const names = lines[number] ?? [];
-        if (!names.includes(test))
-            names.push(test);
-        lines[number] = names;
-        files[file] = lines;
-    }
-    return files;
-}
-function junitMethod(name) {
-    const leaf = name.split("::").pop() ?? name;
-    const dot = leaf.lastIndexOf(".");
-    if (dot <= 0 || dot === leaf.length - 1)
-        return null;
-    if (leaf.startsWith("maven-") || leaf === "javac")
-        return null;
-    return `${leaf.slice(0, dot)}#${leaf.slice(dot + 1)}`;
-}
-function findClassDirs(root) {
-    const found = [];
-    const walk = (dir, depth) => {
-        if (depth > 4)
-            return;
-        let entries = [];
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return;
-        }
-        for (const name of entries) {
-            if (name === "node_modules" || name === ".git" || name === "java-cover")
-                continue;
-            const full = path.join(dir, name);
-            if (name === "target") {
-                const classes = path.join(full, "classes");
-                if (existsSync(classes))
-                    found.push(classes);
-                continue;
-            }
-            if (name.startsWith("."))
-                continue;
-            walk(full, depth + 1);
-        }
-    };
-    walk(root, 0);
-    return found;
-}
-function testClassDirs(root) {
-    return findClassDirs(root).map((dir) => path.join(path.dirname(dir), "test-classes")).filter((dir) => existsSync(dir));
-}
-function resolveJars(pkg, work) {
-    const copies = [
-        [`org.jacoco:org.jacoco.agent:${JACOCO}:jar:runtime`, "agent.jar"],
-        [`org.jacoco:org.jacoco.core:${JACOCO}`, "core.jar"],
-        [`org.ow2.asm:asm:${ASM}`, "asm.jar"],
-        [`org.ow2.asm:asm-commons:${ASM}`, "asm-commons.jar"],
-        [`org.ow2.asm:asm-tree:${ASM}`, "asm-tree.jar"],
-        ["junit:junit:4.13.2", "junit.jar"],
-    ];
-    const paths = {};
-    for (const [artifact, name] of copies) {
-        const dest = path.join(work, name);
-        if (!existsSync(dest)) {
-            const before = new Set(readdirSync(work));
-            const copied = run("mvn", ["-B", "-q", "org.apache.maven.plugins:maven-dependency-plugin:3.6.1:copy", `-Dartifact=${artifact}`, `-DoutputDirectory=${work}`], pkg);
-            if (copied.status !== 0)
-                return { error: clip(copied.stderr || copied.stdout || copied.error?.message || `mvn copy ${artifact} failed`) };
-            const created = readdirSync(work).find((item) => !before.has(item) && item.endsWith(".jar"));
-            if (!created)
-                return { error: `java coverage: missing ${artifact}` };
-            writeFileSync(dest, readFileSync(path.join(work, created)));
-        }
-        paths[name] = dest;
-    }
-    return {
-        agent: paths["agent.jar"],
-        core: paths["core.jar"],
-        asm: paths["asm.jar"],
-        asmCommons: paths["asm-commons.jar"],
-        asmTree: paths["asm-tree.jar"],
-        junit: paths["junit.jar"],
-    };
-}
-/** Launcher jar matching the project's junit-platform-engine, or none when this suite is not Jupiter. */
-function platformLauncherJar(pkg, work, projectCp) {
-    const entries = projectCp.split(path.delimiter).filter(Boolean);
-    if (entries.some((item) => path.basename(item).startsWith("junit-platform-launcher")))
-        return { jar: "" };
-    const engine = entries.find((item) => path.basename(item).startsWith("junit-platform-engine-"));
-    if (!engine)
-        return { jar: "" };
-    const version = path.basename(engine).replace(/^junit-platform-engine-/, "").replace(/\.jar$/, "");
-    if (!version)
-        return { error: "java coverage: junit-platform-engine version missing" };
-    const dest = path.join(work, "launcher.jar");
-    if (!existsSync(dest)) {
-        const artifact = `org.junit.platform:junit-platform-launcher:${version}`;
-        const before = new Set(readdirSync(work));
-        const copied = run("mvn", ["-B", "-q", "org.apache.maven.plugins:maven-dependency-plugin:3.6.1:copy", `-Dartifact=${artifact}`, `-DoutputDirectory=${work}`], pkg);
-        if (copied.status !== 0)
-            return { error: clip(copied.stderr || copied.stdout || copied.error?.message || `mvn copy ${artifact} failed`) };
-        const created = readdirSync(work).find((item) => !before.has(item) && item.endsWith(".jar"));
-        if (!created)
-            return { error: `java coverage: missing ${artifact}` };
-        writeFileSync(dest, readFileSync(path.join(work, created)));
-    }
-    return { jar: dest };
-}
-function buildClasspath(pkg, work) {
-    const file = path.join(work, "classpath.txt");
-    const built = run("mvn", ["-B", "-q", "dependency:build-classpath", "-DincludeScope=test", `-Dmdep.outputFile=${file}`], pkg);
-    if (built.status !== 0)
-        return { error: clip(built.stderr || built.stdout || built.error?.message || "mvn classpath failed") };
-    try {
-        return { cp: readFileSync(file, "utf8").trim() };
-    }
-    catch {
-        return { error: "java coverage: classpath file missing" };
-    }
-}
-function javaTool(name) {
-    const home = process.env.JAVA_HOME;
-    if (home) {
-        const candidate = path.join(home, "bin", name);
-        if (existsSync(candidate) && toolWorks(candidate))
-            return candidate;
-    }
-    if (toolWorks(name))
-        return name;
-    for (const dir of ["/opt/homebrew/opt/openjdk/bin", "/usr/local/opt/openjdk/bin"]) {
-        const candidate = path.join(dir, name);
-        if (existsSync(candidate) && toolWorks(candidate))
-            return candidate;
-    }
-    return name;
-}
-function toolWorks(bin) {
-    const probed = spawnSync(bin, ["-version"], { encoding: "utf8" });
-    const text = `${probed.stdout ?? ""}${probed.stderr ?? ""}`;
-    return probed.status === 0 && !/Unable to locate a Java Runtime/i.test(text);
-}
-function run(bin, args, cwd, timeout = 180_000) {
-    return spawnSync(bin, args, { cwd, encoding: "utf8", timeout });
-}
-function clip(text) {
-    const line = text.trim().split("\n").find((item) => item.trim()) ?? "java coverage failed";
-    return line.slice(0, 240);
-}

package/dist/mutate/kill-label.js

@@ -1,34 +0,0 @@
-/** Names that mean the process failed to compile. These are not test titles. */
-const BUILD_NAMES = new Set([
-    "build",
-    "javac",
-    "compiler",
-    "cobc",
-    "nasm",
-    "clang",
-    "cargo",
-    "tsc",
-    "dotnet",
-    "swiftc",
-]);
-/**
- * A named test and a compile failure are different facts.
- * The build next step says the build failed and does not ask for a test
- * named after the compiler.
- */
-export function killLabel(killedBy) {
-    if (killedBy.length === 0)
-        return null;
-    if (killedBy.every((item) => BUILD_NAMES.has(bareName(item)))) {
-        return { cause: "build", next: "Killed because the build failed. Record it as a compile kill." };
-    }
-    return { cause: "test", next: `Killed by ${killedBy.join(", ")}.` };
-}
-/** True when the id names a compiler, not a test. */
-export function isBuildName(id) {
-    return BUILD_NAMES.has(bareName(id));
-}
-function bareName(id) {
-    const mark = id.lastIndexOf("::");
-    return (mark >= 0 ? id.slice(mark + 2) : id).trim().toLowerCase();
-}

package/dist/mutate/load-failure.mjs

@@ -1,40 +0,0 @@
-// A test file that failed before any test ran either did not link or threw while loading.
-// Did not link: a removed export, a missing module, a file that does not parse. No code ran.
-// A compiled language rejects the same change at compile time, so that mutant is unviable.
-// Threw while loading: the file's own top-level code ran the program and it broke. That is a kill.
-
-const STATIC_ERROR = /^(?:SyntaxError|(?:Type)?Error \[ERR_(?:MODULE_NOT_FOUND|UNKNOWN_FILE_EXTENSION|UNSUPPORTED_DIR_IMPORT|PACKAGE_PATH_NOT_EXPORTED)\]):/
-
-/**
- * `text` is the error as printed: a `Name: message` line, then `at` frames.
- * Static when the error is a link or parse error and no frame is in the project's own code.
- * A SyntaxError thrown by running code (JSON.parse at the top of a test) has a frame in that file.
- */
-export function staticLoadFailure(text) {
-  const lines = String(text).split(/\r?\n/)
-  const head = lines.findIndex((line) => STATIC_ERROR.test(line.trim()))
-  if (head === -1) return false
-  for (const raw of lines.slice(head + 1)) {
-    const line = raw.trim()
-    if (!line.startsWith("at ")) break
-    if (projectFrame(line)) return false
-  }
-  return true
-}
-
-/** The error object a node:test event carries, printed the way node prints it. */
-export function errorText(error) {
-  if (!error || typeof error !== "object") return ""
-  const name = typeof error.name === "string" ? error.name : "Error"
-  const code = typeof error.code === "string" ? ` [${error.code}]` : ""
-  const message = typeof error.message === "string" ? error.message : ""
-  const stack = typeof error.stack === "string" ? error.stack.split("\n").slice(1).join("\n") : ""
-  return `${name}${code}: ${message}\n${stack}`
-}
-
-function projectFrame(frame) {
-  if (/\bnode:/.test(frame) || frame.includes("<anonymous>")) return false
-  const location = /(?:file:\/\/)?(\/[^\s)]+|[A-Za-z]:\\[^\s)]+):\d+:\d+\)?$/.exec(frame)
-  if (!location) return false
-  return !location[1].split(/[\\/]/).includes("node_modules")
-}

package/dist/mutate/mocha-coverage.cjs

@@ -1,77 +0,0 @@
-// Mocha root hooks. This file is not node-coverage.mjs. Mocha does not run
-// node:test afterEach/after, so that collector records no Mocha title.
-// These hooks key inspector hits by the current Mocha title and write { files }.
-const { mkdirSync, writeFileSync } = require("node:fs")
-const path = require("node:path")
-
-const mapPath = process.env.PROBATIO_COVERAGE_MAP
-if (mapPath) {
-  /** @type {Map<string, Map<number, Set<string>>>} */
-  const byFile = new Map()
-  /** @type {Array<{ file: string, line: number }>} */
-  let prelude = []
-  /** @type {{ positiveLines: () => Promise<Array<{ file: string, line: number }>> } | null} */
-  let sampler = null
-  /** @type {((mapPath: string) => Array<{ file: string, line: number }>) | null} */
-  let takeChildHits = null
-
-  function add(hits, name) {
-    if (!name) return
-    for (const hit of hits) {
-      let lines = byFile.get(hit.file)
-      if (!lines) {
-        lines = new Map()
-        byFile.set(hit.file, lines)
-      }
-      let names = lines.get(hit.line)
-      if (!names) {
-        names = new Set()
-        lines.set(hit.line, names)
-      }
-      names.add(name)
-    }
-  }
-
-  function titleOf(test) {
-    if (!test) return ""
-    if (typeof test.fullTitle === "function") return test.fullTitle()
-    return typeof test.title === "string" ? test.title : ""
-  }
-
-  exports.mochaHooks = {
-    async beforeAll() {
-      try {
-        const opened = await import("./precise-lines.mjs")
-        sampler = await opened.openLineSampler((rel) => rel.endsWith("mocha-coverage.cjs") || rel.endsWith("precise-lines.mjs") || rel.endsWith("node-coverage.mjs") || rel.endsWith("child-lines.mjs"))
-        // A node child of a Mocha test is mapped under that test, the same as under node:test.
-        opened.exposeChildLines()
-        takeChildHits = opened.takeChildHits
-        prelude = await sampler.positiveLines()
-      } catch (err) {
-        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-      }
-    },
-    async afterEach() {
-      if (!sampler) return
-      const title = titleOf(this.currentTest)
-      try {
-        add(prelude, title)
-        add(await sampler.positiveLines(), title)
-        if (takeChildHits) add(takeChildHits(mapPath), title)
-      } catch (err) {
-        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-      }
-    },
-    afterAll() {
-      if (byFile.size === 0) return
-      const files = {}
-      for (const [file, lines] of byFile) {
-        const bucket = {}
-        for (const [line, names] of lines) bucket[String(line)] = [...names].sort()
-        files[file] = bucket
-      }
-      mkdirSync(path.dirname(mapPath), { recursive: true })
-      writeFileSync(mapPath, `${JSON.stringify({ files }, null, 2)}\n`)
-    },
-  }
-}