probatio 0.0.5 → 0.1.2

package/dist/mutate/precise-lines.mjs

@@ -0,0 +1,188 @@
+// Inspector line samples shared by the node:test collector, the Mocha collector,
+// and a plain-script child. This file has no test hooks and writes no shard.
+import { Session } from "node:inspector/promises"
+import { findSourceMap } from "node:module"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const B64 = new Int32Array(128)
+for (let i = 0; i < 64; i++) B64["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charCodeAt(i)] = i
+
+function decodeSegments(row) {
+  const segments = []
+  let i = 0
+  while (i < row.length) {
+    const fields = []
+    while (i < row.length && row.charCodeAt(i) !== 44) {
+      let value = 0
+      let shift = 0
+      let digit = 0
+      do {
+        digit = B64[row.charCodeAt(i++)]
+        value |= (digit & 31) << shift
+        shift += 5
+      } while (digit & 32)
+      fields.push(value & 1 ? -(value >> 1) : value >> 1)
+    }
+    if (row.charCodeAt(i) === 44) i++
+    if (fields.length > 0) segments.push(fields)
+  }
+  return segments
+}
+
+/**
+ * @param {(rel: string) => boolean} [skipRel]
+ * @returns {Promise<{ positiveLines: () => Promise<Array<{ file: string, line: number }>>, reset: () => Promise<void> }>}
+ */
+export async function openLineSampler(skipRel) {
+  const session = new Session()
+  session.connect()
+  await session.post("Profiler.enable")
+  await session.post("Debugger.enable")
+  await session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
+
+  const textCache = new Map()
+  const indexCache = new Map()
+
+  async function scriptText(script) {
+    if (textCache.has(script.scriptId)) return textCache.get(script.scriptId)
+    let text = ""
+    try {
+      const got = await session.post("Debugger.getScriptSource", { scriptId: script.scriptId })
+      text = got.scriptSource || ""
+    } catch {
+      text = ""
+    }
+    textCache.set(script.scriptId, text)
+    return text
+  }
+
+  function relPath(url) {
+    if (!url || url.startsWith("node:")) return null
+    let abs
+    try {
+      abs = fileURLToPath(url.split("?")[0].split("#")[0])
+    } catch {
+      return null
+    }
+    const rel = path.relative(process.cwd(), abs).split(path.sep).join("/")
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null
+    if (rel.split("/").includes("node_modules")) return null
+    if (skipRel && skipRel(rel)) return null
+    return rel
+  }
+
+  function indexFor(scriptId, text, sm) {
+    if (indexCache.has(scriptId)) return indexCache.get(scriptId)
+    const mapped = sm && sm.payload && typeof sm.payload.mappings === "string" ? linesFromMappings(text, sm.payload.mappings) : null
+    const lines = mapped && hasLine(mapped) ? mapped : linesFromNewlines(text, sm)
+    indexCache.set(scriptId, lines)
+    return lines
+  }
+
+  function hasLine(lines) {
+    for (let i = 0; i < lines.length; i++) if (lines[i] > 0) return true
+    return false
+  }
+
+  function linesFromNewlines(text, sm) {
+    const lines = new Int32Array(text.length + 1)
+    if (!sm) {
+      let line = 1
+      for (let i = 0; i < text.length; i++) {
+        lines[i] = line
+        if (text.charCodeAt(i) === 10) line++
+      }
+      return lines
+    }
+    let genLine = 0
+    let col = 0
+    for (let i = 0; i < text.length; i++) {
+      const entry = sm.findEntry(genLine, col)
+      if (entry && Number.isInteger(entry.originalLine) && entry.originalLine >= 0) lines[i] = entry.originalLine + 1
+      if (text.charCodeAt(i) === 10) {
+        genLine++
+        col = 0
+      } else {
+        col++
+      }
+    }
+    return lines
+  }
+
+  function linesFromMappings(text, mappings) {
+    const lines = new Int32Array(text.length + 1)
+    const starts = [0]
+    for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1)
+    let carryLine = 0
+    const rows = mappings.split(";")
+    for (let genLine = 0; genLine < rows.length && genLine < starts.length; genLine++) {
+      const start = starts[genLine]
+      const next = genLine + 1 < starts.length ? starts[genLine + 1] : text.length
+      let col = 0
+      let cursor = start
+      let active = -1
+      for (const fields of decodeSegments(rows[genLine])) {
+        col += fields[0]
+        const at = Math.min(next, start + Math.max(0, col))
+        if (active >= 0) {
+          for (let i = cursor; i < at; i++) lines[i] = active + 1
+        }
+        cursor = at
+        if (fields.length >= 4) {
+          carryLine += fields[2]
+          active = carryLine
+        } else {
+          active = -1
+        }
+      }
+      if (active >= 0) {
+        for (let i = cursor; i < next; i++) lines[i] = active + 1
+      }
+    }
+    return lines
+  }
+
+  function applyRanges(text, script, lines) {
+    const ranges = []
+    for (const fn of script.functions || []) {
+      for (const range of fn.ranges || []) ranges.push(range)
+    }
+    ranges.sort((a, b) => a.startOffset - b.startOffset || b.endOffset - a.endOffset)
+    const offsets = new Int32Array(text.length)
+    for (const range of ranges) {
+      const end = Math.min(text.length, range.endOffset)
+      for (let i = Math.max(0, range.startOffset); i < end; i++) offsets[i] = range.count
+    }
+    const counts = new Map()
+    for (let i = 0; i < text.length; i++) {
+      const line = lines[i]
+      if (line <= 0 || offsets[i] <= 0) continue
+      if (offsets[i] > (counts.get(line) || 0)) counts.set(line, offsets[i])
+    }
+    return counts
+  }
+
+  async function positiveLines() {
+    const cov = await session.post("Profiler.takePreciseCoverage")
+    const found = []
+    for (const script of cov.result || []) {
+      const file = relPath(script.url)
+      if (!file) continue
+      const text = await scriptText(script)
+      if (!text) continue
+      const counts = applyRanges(text, script, indexFor(script.scriptId, text, findSourceMap(script.url)))
+      for (const [line, count] of counts) {
+        if (count > 0) found.push({ file, line })
+      }
+    }
+    return found
+  }
+
+  return {
+    positiveLines,
+    reset: async () => {
+      await session.post("Profiler.takePreciseCoverage")
+    },
+  }
+}

package/dist/mutate/probatio-jacoco-run.java

@@ -252,11 +252,17 @@ public class ProbatioJacocoRun {
       Class<?> selectorType = Class.forName("org.junit.platform.engine.DiscoverySelector");
       Class<?> selectorsType = Class.forName("org.junit.platform.engine.discovery.DiscoverySelectors");
       java.lang.reflect.Method select = selectMethodWithTypes(selectorsType);
+      boolean typed = select.getParameterCount() == 3;
       Object selectors = Array.newInstance(selectorType, unique.size());
       int index = 0;
       for (JupiterSpec spec : unique.values()) {
         Class<?> type = loadTestClass(spec.className);
-        Object selector = select.invoke(null, new Object[] { type, spec.simple, spec.types });
+        // Platform 1.7 has selectMethod(Class, String) only. 5.14's two-argument
+        // form drops the parameter list and can run nothing, so keep the types
+        // when that overload exists.
+        Object selector = typed
+          ? select.invoke(null, new Object[] { type, spec.simple, spec.types })
+          : select.invoke(null, new Object[] { type, spec.simple });
         Array.set(selectors, index++, selector);
       }
       Class<?> builderType = Class.forName("org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder");
@@ -426,13 +432,16 @@ public class ProbatioJacocoRun {
   }
 
   static java.lang.reflect.Method selectMethodWithTypes(Class<?> selectorsType) throws NoSuchMethodException {
+    java.lang.reflect.Method byName = null;
     for (java.lang.reflect.Method candidate : selectorsType.getMethods()) {
       if (!candidate.getName().equals("selectMethod")) continue;
       Class<?>[] params = candidate.getParameterTypes();
       if (params.length == 3 && params[0] == Class.class && params[1] == String.class && params[2].isArray() && params[2].getComponentType() == Class.class) {
         return candidate;
       }
+      if (params.length == 2 && params[0] == Class.class && params[1] == String.class) byName = candidate;
     }
+    if (byName != null) return byName;
     throw new NoSuchMethodException("selectMethod(Class, String, Class[])");
   }
 

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) {
@@ -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)));
@@ -217,7 +244,7 @@ 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");
@@ -263,7 +290,8 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
                 return finishMutant(killed(base, direction, ["build"]), pkg, "", false, []);
         }
         const picked = selectionFor(prep.coverage, edited.length > 0 ? edited : files);
-        if (picked.state === "uncovered") {
+        const forced = options.onlyNames && options.onlyNames.length > 0 ? options.onlyNames : null;
+        if (!forced && picked.state === "uncovered") {
             return {
                 ...base(),
                 direction,
@@ -271,14 +299,20 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
                 next: noCoverageNext(picked.file, picked.line),
             };
         }
-        const names = picked.state === "covered" ? picked.tests.filter((name) => name !== WHOLE_PROGRAM_TEST) : null;
+        const names = forced ?? (picked.state === "covered" ? picked.tests.filter((name) => name !== WHOLE_PROGRAM_TEST) : null);
         const forceWhole = picked.state === "covered" && (names === null || names.length === 0);
         // 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);
         }
@@ -403,6 +437,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);
@@ -927,15 +1119,28 @@ function findTestFile(pkg, rel) {
 function sha256(text) {
     return createHash("sha256").update(text).digest("hex");
 }
+const BARE_SUITE = new Set(["command", "suite", "pytest", "unittest", "cobol", "make-test", "c", "cpp"]);
 function failureId(pkg, failure) {
     // Pytest already reports a node id (tests/test_gate.py::test_low). Prepending the
     // file doubles it, and pytest then exits 4 and collects nothing.
     if (pytestNodeId(failure.name))
         return failure.name;
-    const rel = failure.file ? path.relative(pkg, failure.file) : "";
-    const file = !rel || rel.startsWith("..") ? path.basename(failure.file || "") : rel.split(path.sep).join("/");
+    // Cargo and dotnet report a bare test name. Go reports a package path that is
+    // not a file, and JUnit reports a classname. The runnable id is the name itself.
+    // An unnamed shell suite stays ::command so a tally does not treat it as a test.
+    if (!failure.file)
+        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);
+    const file = !rel || rel.startsWith("..") ? path.basename(failure.file) : rel.split(path.sep).join("/");
     return `${file}::${failure.name}`;
 }
+function testFileOnDisk(pkg, file) {
+    if (path.isAbsolute(file))
+        return existsSync(file);
+    return existsSync(path.join(pkg, file));
+}
 function pytestNodeId(name) {
     const mark = name.indexOf("::");
     if (mark <= 0)

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. */