probatio 0.0.0-stage → 0.0.2

package/dist/mutate/affected.js

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+const IMPORT_SPEC = /(?:from\s+|import\s*\(\s*|import\s+)["'](\.{1,2}\/[^"']+)["']/g;
+/** Package-relative source file to the test files that can see a change in it. */
+export function affectedTests(packageDir, options = {}) {
+    const srcRel = options.srcDir ?? "src";
+    const testsRel = options.testsDir ?? "tests";
+    const srcDir = path.join(packageDir, srcRel);
+    const testsDir = path.join(packageDir, testsRel);
+    const alwaysPattern = options.alwaysPattern ?? /\b(?:spawn|execFile|execSync)\b|dist\//;
+    const sources = walk(srcDir, (name) => /\.(ts|tsx|py)$/.test(name) && !name.endsWith(".d.ts"));
+    const tests = existsSync(testsDir)
+        ? readdirSync(testsDir)
+            .filter((name) => /\.test\.(ts|tsx|mts|js|mjs)$/.test(name))
+            .sort()
+        : [];
+    const imports = new Map();
+    const read = (file) => {
+        const found = imports.get(file);
+        if (found)
+            return found;
+        const out = new Set();
+        imports.set(file, out);
+        if (!existsSync(file))
+            return out;
+        const text = readFileSync(file, "utf8");
+        for (const match of text.matchAll(IMPORT_SPEC)) {
+            const resolved = resolveImport(path.dirname(file), match[1]);
+            if (resolved)
+                out.add(resolved);
+        }
+        return out;
+    };
+    const closureOf = (file) => {
+        const seen = new Set();
+        const stack = [file];
+        while (stack.length) {
+            const current = stack.pop();
+            if (!current || seen.has(current))
+                continue;
+            seen.add(current);
+            for (const next of read(current))
+                stack.push(next);
+        }
+        return seen;
+    };
+    const rel = (file) => path.relative(packageDir, file).split(path.sep).join("/");
+    const byModule = new Map();
+    for (const source of sources)
+        byModule.set(rel(source), new Set());
+    const testRel = (name) => `${testsRel}/${name}`.replace(/\\/g, "/");
+    const always = [];
+    for (const test of tests) {
+        const text = readFileSync(path.join(testsDir, test), "utf8");
+        if (alwaysPattern.test(text))
+            always.push(testRel(test));
+    }
+    for (const names of byModule.values())
+        for (const test of always)
+            names.add(test);
+    for (const test of tests) {
+        const seen = closureOf(path.join(testsDir, test));
+        for (const file of seen) {
+            const key = rel(file);
+            const testsForFile = byModule.get(key);
+            if (testsForFile)
+                testsForFile.add(testRel(test));
+        }
+        const blob = [path.join(testsDir, test), ...seen].map((file) => (existsSync(file) ? readFileSync(file, "utf8") : "")).join("\n");
+        for (const source of sources) {
+            if (!source.endsWith(".py"))
+                continue;
+            if (blob.includes(path.basename(source)))
+                byModule.get(rel(source))?.add(testRel(test));
+        }
+    }
+    for (const testFile of walk(testsDir, (name) => /^test_.*\.py$/.test(name) || /_test\.py$/.test(name))) {
+        const text = readFileSync(testFile, "utf8");
+        const relTest = rel(testFile);
+        for (const source of sources) {
+            if (!source.endsWith(".py"))
+                continue;
+            const moduleName = pythonModuleName(rel(source));
+            if (!moduleName)
+                continue;
+            const pattern = new RegExp(`(?<![\\w.])${escapeRegExp(moduleName)}(?![\\w.])`);
+            if (pattern.test(text))
+                byModule.get(rel(source))?.add(relTest);
+        }
+    }
+    return Object.fromEntries([...byModule.entries()].sort().map(([file, names]) => [file, [...names].sort()]));
+}
+/** Test files that import one of `changed` themselves, not through another module. */
+export function directImporters(packageDir, changed, testsDir = "tests") {
+    const testsRoot = path.join(packageDir, testsDir);
+    if (!existsSync(testsRoot))
+        return [];
+    const wanted = new Set(changed.map((file) => path.resolve(packageDir, file)));
+    const out = [];
+    const seen = new Set();
+    const add = (rel) => {
+        if (seen.has(rel))
+            return;
+        seen.add(rel);
+        out.push(rel);
+    };
+    for (const name of readdirSync(testsRoot).filter((item) => /\.test\.(ts|tsx|mts|js|mjs)$/.test(item)).sort()) {
+        const file = path.join(testsRoot, name);
+        const text = readFileSync(file, "utf8");
+        for (const match of text.matchAll(IMPORT_SPEC)) {
+            const resolved = resolveImport(path.dirname(file), match[1]);
+            if (resolved && wanted.has(resolved)) {
+                add(`${testsDir}/${name}`.replace(/\\/g, "/"));
+                break;
+            }
+        }
+    }
+    const patterns = changed
+        .map((file) => pythonModuleName(file))
+        .filter((name) => name !== null)
+        .map((name) => new RegExp(`(?<![\\w.])${escapeRegExp(name)}(?![\\w.])`));
+    if (patterns.length > 0) {
+        for (const file of walk(testsRoot, (name) => /^test_.*\.py$/.test(name) || /_test\.py$/.test(name))) {
+            const text = readFileSync(file, "utf8");
+            if (!patterns.some((pattern) => pattern.test(text)))
+                continue;
+            add(path.relative(packageDir, file).split(path.sep).join("/"));
+        }
+    }
+    return out;
+}
+/** `src/pkg/mod.py` is the import name `pkg.mod`. */
+function pythonModuleName(file) {
+    const norm = file.split(path.sep).join("/");
+    if (!norm.endsWith(".py"))
+        return null;
+    let body = norm.slice(0, -3);
+    if (body.startsWith("src/"))
+        body = body.slice(4);
+    if (body.endsWith("/__init__"))
+        body = body.slice(0, -"/__init__".length);
+    if (!body || body.startsWith("../"))
+        return null;
+    return body.split("/").join(".");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function resolveImport(fromDir, spec) {
+    const target = path.resolve(fromDir, spec);
+    const candidates = [target, `${target}.ts`, `${target}.tsx`, `${target}.mts`, `${target}.js`, `${target}.mjs`, `${target}.py`];
+    for (const candidate of candidates) {
+        if (existsSync(candidate) && statSync(candidate).isFile())
+            return candidate;
+    }
+    return null;
+}
+function walk(dir, keep) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    const visit = (current) => {
+        for (const entry of readdirSync(current).sort()) {
+            const full = path.join(current, entry);
+            if (statSync(full).isDirectory())
+                visit(full);
+            else if (keep(entry))
+                out.push(full);
+        }
+    };
+    visit(dir);
+    return out;
+}

package/dist/mutate/coverage-map.js

@@ -0,0 +1,172 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { WHOLE_PROGRAM_TEST } from "./suite-decision.js";
+export function readCoverageMap(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed.files !== "object" || parsed.files === null)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Lines the baseline executed, and the tests that hit them. No map means no decision. */
+export function selectionFor(map, files) {
+    if (!map || Object.keys(map.files).length === 0 || files.length === 0)
+        return { state: "none" };
+    const tests = new Set();
+    let sawUncovered = false;
+    let uncovered = files[0];
+    for (const item of files) {
+        const hit = testsOnLine(map, item.file, item.line);
+        if (hit === null) {
+            sawUncovered = true;
+            uncovered = item;
+            continue;
+        }
+        for (const name of hit)
+            tests.add(name);
+    }
+    if (tests.size === 0 && sawUncovered)
+        return { state: "uncovered", file: uncovered.file, line: uncovered.line };
+    if (tests.size === 0)
+        return { state: "none" };
+    const [file, line] = coveredAnchor(map, files);
+    return { state: "covered", file, line, tests: [...tests] };
+}
+function coveredAnchor(map, files) {
+    for (const item of files) {
+        if (testsOnLine(map, item.file, item.line))
+            return [item.file, item.line];
+    }
+    return [files[0].file, files[0].line];
+}
+function testsOnLine(map, file, line) {
+    const lines = linesFor(map, file);
+    if (!lines)
+        return null;
+    const tests = lines[String(line)];
+    if (!tests || tests.length === 0)
+        return null;
+    return tests;
+}
+function linesFor(map, file) {
+    const norm = file.split(path.sep).join("/");
+    if (map.files[norm])
+        return map.files[norm];
+    if (map.files[file])
+        return map.files[file];
+    // A repo-relative patch can be longer than the package-relative map key.
+    // The longest suffix wins, so span/simple.py does not steal span_handlers/simple.py.
+    let best = null;
+    let bestLen = -1;
+    const baseHits = [];
+    const base = norm.split("/").pop() ?? norm;
+    for (const [name, lines] of Object.entries(map.files)) {
+        const key = name.split(path.sep).join("/");
+        if (key === norm || norm.endsWith(`/${key}`) || key.endsWith(`/${norm}`)) {
+            if (key.length > bestLen) {
+                best = lines;
+                bestLen = key.length;
+            }
+        }
+        if (key === base || key.endsWith(`/${base}`))
+            baseHits.push(lines);
+    }
+    if (best)
+        return best;
+    if (baseHits.length === 1)
+        return baseHits[0];
+    return null;
+}
+export function binaryFromCommand(command, pkg) {
+    const match = command.match(/(?:^|\s)-o\s+["']?([^\s"']+)["']?/);
+    if (!match)
+        return null;
+    const rel = match[1];
+    const full = path.isAbsolute(rel) ? rel : path.join(pkg, rel);
+    return existsSync(full) ? full : null;
+}
+/**
+ * Build a line map from LLVM profraw left by an instrumented baseline.
+ * Writes nothing when llvm-cov cannot start or no profile was produced.
+ */
+export function writeLlvmCoverage(pkg, profileDir, binary, dest) {
+    if (!existsSync(profileDir))
+        return { ok: false, detail: "no profile directory" };
+    const raws = readdirSync(profileDir).filter((name) => name.endsWith(".profraw")).map((name) => path.join(profileDir, name));
+    if (raws.length === 0)
+        return { ok: false, detail: "no profraw" };
+    if (!binary)
+        return { ok: false, detail: "no instrumented binary" };
+    const llvmCov = findTool("llvm-cov");
+    const llvmProf = findTool("llvm-profdata");
+    if (!llvmCov || !llvmProf)
+        return { ok: false, detail: `llvm tool missing (${llvmCov ? "llvm-profdata" : "llvm-cov"})` };
+    const merged = path.join(profileDir, "baseline.profdata");
+    const merge = spawnSync(llvmProf, ["merge", "-sparse", "-o", merged, ...raws], { encoding: "utf8" });
+    if (merge.status !== 0)
+        return { ok: false, detail: (merge.stderr || merge.stdout || "llvm-profdata failed").trim() };
+    const exported = spawnSync(llvmCov, ["export", binary, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    if (exported.status !== 0)
+        return { ok: false, detail: (exported.stderr || exported.stdout || "llvm-cov failed").trim() };
+    const map = llvmExportToMap(exported.stdout, pkg);
+    if (!map)
+        return { ok: false, detail: "llvm-cov export was not a coverage map" };
+    writeFileSync(dest, `${JSON.stringify(map, null, 2)}\n`);
+    return { ok: true, detail: `${Object.keys(map.files).length} files` };
+}
+function llvmExportToMap(stdout, pkg) {
+    const start = stdout.indexOf("{");
+    if (start < 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.slice(start));
+    }
+    catch {
+        return null;
+    }
+    const files = {};
+    const root = pkg.endsWith(path.sep) ? pkg : `${pkg}${path.sep}`;
+    for (const group of parsed.data ?? []) {
+        for (const file of group.files ?? []) {
+            if (!file.filename)
+                continue;
+            const lines = {};
+            for (const segment of file.segments ?? []) {
+                const line = segment[0];
+                const count = segment[2] ?? 0;
+                if (!line || count <= 0)
+                    continue;
+                lines[String(line)] = [WHOLE_PROGRAM_TEST];
+            }
+            if (Object.keys(lines).length === 0)
+                continue;
+            let rel = file.filename;
+            if (rel.startsWith(root))
+                rel = rel.slice(root.length);
+            rel = rel.split(path.sep).join("/");
+            files[rel] = { ...(files[rel] ?? {}), ...lines };
+        }
+    }
+    if (Object.keys(files).length === 0)
+        return null;
+    return { files };
+}
+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;
+}

package/dist/mutate/fail-reporter.mjs

@@ -0,0 +1,44 @@
+// node --test custom reporter. One JSON object on stdout: failures with the file
+// the runner itself recorded. TAP headings are not used.
+export default async function* reporter(source) {
+  const failed = []
+  const names = []
+  let tests = 0
+  let pass = 0
+  let fail = 0
+  for await (const event of source) {
+    if (event.type === "test:pass" || event.type === "test:fail") {
+      const data = event.data ?? {}
+      if (data.details && data.details.type === "suite") continue
+      const name = String(data.name ?? "")
+      const file = String(data.file ?? "")
+      names.push(name)
+      if (event.type === "test:fail") {
+        const failure = { name, file, line: Number(data.line ?? 0) }
+        // An open handle is reported as a timeout whose name is the file path.
+        // failureType lives on the error; the text is on error.cause, not message.
+        if (fileTimedOut(name, file, data.details?.error)) failure.fileTimeout = true
+        failed.push(failure)
+      }
+    } else if (event.type === "test:diagnostic") {
+      const message = String(event.data?.message ?? "")
+      const match = message.match(/^(tests|pass|fail) (\d+)$/)
+      if (!match) continue
+      const count = Number(match[2])
+      if (match[1] === "tests") tests = count
+      else if (match[1] === "pass") pass = count
+      else fail = count
+    }
+  }
+  yield JSON.stringify({ tests, pass, fail, failed, names })
+}
+
+function fileTimedOut(name, file, error) {
+  if (!error || typeof error !== "object") return false
+  const cause = typeof error.cause === "string" ? error.cause : ""
+  const text = `${error.failureType ?? ""} ${error.message ?? ""} ${cause}`
+  if (!/testTimeoutFailure|timed out/i.test(text)) return false
+  const base = String(file).split(/[/\\]/).pop()
+  if (!base) return false
+  return name === file || name === base || name.endsWith(`/${base}`) || name.endsWith(`\\${base}`)
+}

package/dist/mutate/find.js

@@ -0,0 +1,13 @@
+import { findMutants } from "./operators.js";
+import { findTextMutants, textKind } from "./text-operators.js";
+/** TypeScript stays on the TypeScript parser. Every other recognized source uses its own finder. */
+export function findInSource(file, text) {
+    if (textKind(file))
+        return findTextMutants(file, text);
+    return findMutants(file, text);
+}
+export function isGeneratedSource(name) {
+    if (textKind(name))
+        return true;
+    return (name.endsWith(".ts") || name.endsWith(".tsx")) && !name.endsWith(".d.ts");
+}

package/dist/mutate/generate.js

@@ -0,0 +1,132 @@
+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;
+    if (over())
+        return { mutants: [], violations: [], filesVisited: 0, budgetHit: true };
+    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;
+    for (const file of files) {
+        if (over()) {
+            budgetHit = true;
+            break;
+        }
+        filesVisited += 1;
+        const text = readFileSync(file, "utf8");
+        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 };
+    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 };
+}
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,22 @@
+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;
+}