probatio 0.1.0 → 0.1.2

package/README.md

@@ -5,7 +5,7 @@ Probatio (Latin: a testing, a proof) is a free testing toolkit under the MIT lic
 It remembers what was fixed so agents with small context do not redo or undo work, and it shows
 which tests already touch a change.
 
-Status (2026-10-06): `mutate run` discovers the project suite and scores it. Node, pytest, C (when the binary was built with LLVM coverage), Go, Maven/Java, Rust, and C# collect a line map on the baseline. A line no test executes is `no coverage`, and the suite is not started. A line that runs only in a child process the map cannot see is `no coverage`. A suite with no line map, a baseline of 5 seconds or more, and more than 30 mutants stops before the first mutant. `verify-change` names the tests the line map ran. `ran` stays the direct-importer list. `mutate tally` does not delete a test. A kill is an assertion the suite already had. A sealed miss means the suite did not see the bug. The kill count is not a merge gate. On Commons CSV (Apache-2.0, commit `2c83a308`), two sealed runs agreed: with the new test file hidden, `CSVFormatTest.testFormatThrowsNullPointerException` failed on the reverted printer. `deletedTests` stayed 0. That older JUnit platform did not write a line map, so the first pass was the whole suite and confirm reran the older test. Auspex, markupsafe, and a hand-planted fixture are not that result. The package version in this repository is 0.1.0. The copy on npm is 0.0.5. The BugsInPy search row is still open, and the rows that apply only when a sealed run misses do not apply, because this catch held. The MCP server speaks one JSON object per line and returns the same JSON as the CLI.
+Status (2026-10-06): `mutate run` discovers the project suite and scores it. Node, pytest, C (when the binary was built with LLVM coverage), Go, Maven/Java, Rust, C#, and Mocha collect a line map on the baseline. Mocha's map comes from its own root hooks. Loading the node:test collector under Mocha does not name Mocha tests. A line no test executes is `no coverage`, and the suite is not started. A plain Node script can write the lines it ran, and the parent test that reads that dump stores them under its own name. A child the parent does not read stays `no coverage`, and the suite is not started. A suite with no line map, a baseline of 5 seconds or more, and more than 30 mutants stops before the first mutant. `verify-change` names the tests the line map ran. It scores `src/`, a `lib/` file when the package tests import `lib/`, and a Go file beside `go.mod`. Tests, docs, `dist/`, and `node_modules` stay unseen. `ran` stays the direct-importer list. Covered mutants of one Node file run one after another inside the suite process that is already running. `--workers` stays 1. A Node test that sets its own `timeout` keeps that time when `--test-timeout-ms` is shorter. A mutant that crashes or leaves that process dirty ends it, and the next mutant starts clean. An uncovered line still does not start the suite. `mutate tally` does not delete a test. A kill is an assertion the suite already had. A sealed miss means the suite did not see the bug. The kill count is not a merge gate. On Commons CSV (Apache-2.0, commit `2c83a308`), two sealed runs agreed: with the new test file hidden, `CSVFormatTest.testFormatThrowsNullPointerException` failed on the reverted printer. `deletedTests` stayed 0. That older JUnit platform did not write a line map, so the first pass was the whole suite and confirm reran the older test. Auspex, markupsafe, and a hand-planted fixture are not that result. The package version in this repository is 0.1.2. npm latest is 0.1.0. The BugsInPy search row is still open, and the rows that apply only when a sealed run misses do not apply, because this catch held. The MCP server speaks one JSON object per line and returns the same JSON as the CLI.
 
 Read in this order:
 
@@ -31,7 +31,7 @@ npx probatio mutate tally --out .probatio/runs
 
 `run` discovers the suite: `run_tests.sh`, Cargo, Go, Swift, Maven, dotnet, pytest, unittest, node:test, Mocha, then `make test` when COBOL tests sit under that Makefile. An unknown layout stops and asks for `--suite-command`. It does not compile one file and call that the suite. `make test` that would curl or wget a missing file stops, and nothing is fetched. A worktree that has no `node_modules` uses the main checkout's. Omitting `--build` runs no build. Pass `--build` with a command when the suite needs one first.
 
-Node, pytest, Go, Maven/Java, Rust, and C# collect a line map on the baseline. C collects one when LLVM coverage was instrumented. The map stores the file, the line, and the test names that hit that line. A later mutant runs only those tests (`go test -run`, Maven `-Dtest`, `cargo test`, `dotnet test --filter`). A line no test executed is `no coverage`, and the suite is not started. A child process the map cannot see is `no coverage`. A baseline of 5 seconds or more, with no line map and more than 30 mutants still pending, stops before the first mutant. `next` names that baseline and tells you to narrow `--src` or pass a smaller patch directory. A one-file C, C++, Java, COBOL, or assembly launcher is not a suite discovery returns.
+Node, pytest, Go, Maven/Java, Rust, C#, and Mocha collect a line map on the baseline. C collects one when LLVM coverage was instrumented. Mocha writes its own `{ files }` record from root hooks, keyed by the Mocha title. The node:test collector is a different file and does not name Mocha tests. The map stores the file, the line, and the test names that hit that line. A later mutant runs only those tests (`go test -run`, Maven `-Dtest`, `cargo test`, `dotnet test --filter`, Mocha `--grep`). A line no test executed is `no coverage`, and the suite is not started. A plain Node script can leave a nameless list of the lines it ran. The parent test that reads that list stores them under its own name. A child the parent does not read stays `no coverage`. Covered mutants of one Node file are applied one after another in the suite process already running, and the line map is reset between them. `--workers` stays 1. A crash or a process left dirty ends that process. The next mutant starts clean. A baseline of 5 seconds or more, with no line map and more than 30 mutants still pending, stops before the first mutant. `next` names that baseline and tells you to narrow `--src` or pass a smaller patch directory. A one-file C, C++, Java, COBOL, or assembly launcher is not a suite discovery returns.
 
 The mutant timeout is the baseline duration times 5, and at least 20 seconds, capped by `--suite-timeout-ms`. A timeout is not a kill. `--budget-ms` stops mutant work after the baseline. The first mutant still runs, except for that no-line-map stop. A kill is the test that failed, or a compiler token when the mutant did not build. Confirm is on by default and reruns the failing names. Pytest names that `-k` cannot express are passed as node ids. A usage error, including pytest exit 4, is not a kill. `verify-change` does not confirm a second time. Add `--affected` to limit the file list to tests that can see the change. The default, once a line map exists, runs the tests on the changed line.
 

package/dist/mutate/child-lines.mjs

@@ -0,0 +1,34 @@
+// Nameless line dump for a plain script. This is not a node:test process and it
+// does not write a coverage shard. The parent test's afterEach reads the dump.
+import { randomBytes } from "node:crypto"
+import { mkdirSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { openLineSampler } from "./precise-lines.mjs"
+
+const mapPath = process.env.PROBATIO_COVERAGE_MAP
+if (mapPath) {
+  let sampler = null
+  try {
+    sampler = await openLineSampler((rel) => rel.endsWith("child-lines.mjs") || rel.endsWith("precise-lines.mjs"))
+  } catch (err) {
+    writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
+  }
+  if (sampler) {
+    let wrote = false
+    const dump = () => {
+      if (wrote) return
+      wrote = true
+      sampler.positiveLines().then((hits) => {
+        const dir = `${mapPath}.children`
+        mkdirSync(dir, { recursive: true })
+        writeFileSync(
+          path.join(dir, `${process.pid}-${randomBytes(4).toString("hex")}.json`),
+          JSON.stringify({ hits }),
+        )
+      }).catch((err) => {
+        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
+      })
+    }
+    process.on("beforeExit", dump)
+  }
+}

package/dist/mutate/mocha-coverage.cjs

@@ -0,0 +1,71 @@
+// 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
+
+  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"))
+        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)
+      } 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`)
+    },
+  }
+}

package/dist/mutate/node-batch-loader.mjs

@@ -0,0 +1,85 @@
+// Cache-busts package files so the next mutant in this process loads the patched source.
+// The generation lives in a file because the loader thread does not see later env edits.
+import { createRequire } from "node:module"
+import { readFileSync, realpathSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const require = createRequire(import.meta.url)
+const ts = require("typescript")
+
+function generation() {
+  const file = process.env.PB_GEN
+  if (!file) return ""
+  try {
+    return readFileSync(file, "utf8").trim()
+  } catch {
+    return ""
+  }
+}
+
+function packageRoot() {
+  const root = process.env.PB_ROOT
+  if (!root) return ""
+  try {
+    return realpathSync(root)
+  } catch {
+    return root
+  }
+}
+
+function underPackage(abs) {
+  const root = packageRoot()
+  if (!root) return false
+  let real = abs
+  try {
+    real = realpathSync(abs)
+  } catch {
+    return false
+  }
+  return real === root || real.startsWith(root.endsWith(path.sep) ? root : root + path.sep)
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  const resolved = await nextResolve(specifier, context)
+  const gen = generation()
+  if (!gen) return resolved
+  let abs
+  try {
+    abs = fileURLToPath(resolved.url.split("?")[0])
+  } catch {
+    return resolved
+  }
+  if (!underPackage(abs)) return resolved
+  if (abs.split(path.sep).includes("node_modules")) return resolved
+  const url = new URL(resolved.url.split("?")[0])
+  url.searchParams.set("pb", gen)
+  return { url: url.href, shortCircuit: true }
+}
+
+export async function load(url, context, nextLoad) {
+  if (!url.includes("pb=")) return nextLoad(url, context)
+  const clean = url.split("?")[0]
+  let abs
+  try {
+    abs = fileURLToPath(clean)
+  } catch {
+    return nextLoad(url, context)
+  }
+  const source = readFileSync(abs, "utf8")
+  if (abs.endsWith(".ts") || abs.endsWith(".tsx") || abs.endsWith(".mts")) {
+    const transpiled = ts.transpileModule(source, {
+      fileName: abs,
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ES2022,
+        sourceMap: false,
+      },
+    })
+    return { format: "module", source: transpiled.outputText, shortCircuit: true }
+  }
+  if (abs.endsWith(".mjs") || abs.endsWith(".js") || source.includes("import ") || source.includes("export ")) {
+    return { format: "module", source, shortCircuit: true }
+  }
+  return { format: "commonjs", source, shortCircuit: true }
+}

package/dist/mutate/node-batch.mjs

@@ -0,0 +1,130 @@
+// One suite process for covered mutants of one file. Jobs arrive on stdin.
+// A mutant that exits this process ends it. The parent starts a clean process for the next mutant.
+import { createInterface } from "node:readline"
+import { realpathSync, writeFileSync } from "node:fs"
+import { register } from "node:module"
+import { run } from "node:test"
+import path from "node:path"
+import { openLineSampler } from "./precise-lines.mjs"
+
+const loader = new URL("./node-batch-loader.mjs", import.meta.url).href
+register(loader, { parentURL: import.meta.url })
+
+let sampler = null
+try {
+  sampler = await openLineSampler()
+} catch {
+  sampler = null
+}
+
+writeFileSync(process.env.PB_READY, `${JSON.stringify({ pid: process.pid })}\n`)
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+let generation = 0
+
+async function runJob(job) {
+  generation += 1
+  writeFileSync(process.env.PB_GEN, String(generation))
+  if (sampler) await sampler.reset()
+  const files = (job.tests || []).map((rel) => path.join(job.root, rel))
+  const patterns = (job.names || []).filter((name) => name.length > 0).map((name) => new RegExp(`^${escapeRegExp(name)}$`))
+  const failed = []
+  const names = []
+  const testTimeout = job.testTimeoutMs > 0 ? job.testTimeoutMs : job.timeoutMs
+  const stream = run({
+    files,
+    isolation: "none",
+    timeout: testTimeout,
+    ...(patterns.length > 0 ? { testNamePatterns: patterns } : {}),
+  })
+  let lastEvent = Date.now()
+  const started = Date.now()
+  let ended = false
+  let timer = null
+  const collected = (async () => {
+    for await (const event of stream) {
+      lastEvent = Date.now()
+      if (event.type !== "test:pass" && event.type !== "test:fail") continue
+      const data = event.data || {}
+      const name = typeof data.name === "string" ? data.name : ""
+      if (!name || files.includes(name)) continue
+      if (!names.includes(name)) names.push(name)
+      if (event.type === "test:fail") {
+        const error = data.details && data.details.error
+        const text = error ? `${error.failureType || ""} ${error.message || ""} ${error.cause || ""}` : ""
+        const fileTimeout = /testTimeoutFailure|timed out/i.test(text) && fileNameIs(name, data.file || "")
+        failed.push({ name, file: data.file || "", line: data.line || 0, ...(fileTimeout ? { fileTimeout: true } : {}) })
+      }
+    }
+    ended = true
+  })()
+  let dirty = false
+  try {
+    dirty = await Promise.race([
+      collected.then(() => false),
+      new Promise((resolve) => {
+        timer = setInterval(() => {
+          if (ended) {
+            resolve(false)
+            return
+          }
+          const idle = Date.now() - lastEvent
+          const overdue = Date.now() - started >= testTimeout && idle >= 400 && names.length > 0
+          if (!overdue) return
+          resolve(true)
+        }, 50)
+        timer.unref()
+      }),
+    ])
+  } finally {
+    if (timer) clearInterval(timer)
+  }
+  if (dirty && failed.length === 0) {
+    for (const rel of job.tests || []) {
+      const posix = rel.split(path.sep).join("/")
+      let file = path.join(job.root, rel)
+      try {
+        file = realpathSync(file)
+      } catch {
+        // The reporter uses the path it opened. A missing file keeps the joined path.
+      }
+      failed.push({ name: posix, file, line: 1, fileTimeout: true })
+      if (!names.includes(posix)) names.push(posix)
+    }
+  }
+  if (sampler && !dirty) await sampler.reset()
+  const pattern = (job.names || []).join("|")
+  const command = ["node", "--test", ...(pattern ? [`--test-name-pattern=${pattern}`] : []), ...(job.tests || [])].join(" ")
+  return { id: job.id, pid: process.pid, failed, names, command, dirty }
+}
+
+function fileNameIs(name, file) {
+  const base = String(file).split(/[/\\]/).pop()
+  if (!base) return false
+  return name === file || name === base || name.endsWith(`/${base}`) || name.endsWith(`\\${base}`)
+}
+
+const lines = createInterface({ input: process.stdin })
+for await (const line of lines) {
+  if (!line.trim()) continue
+  const job = JSON.parse(line)
+  // node:test with isolation "none" waits until the event loop is idle.
+  // An open readline on stdin is that handle, so the job would never finish.
+  lines.pause()
+  process.stdin.unref()
+  try {
+    const reply = await runJob(job)
+    writeFileSync(job.replyFile, `${JSON.stringify(reply)}\n`)
+    // An open handle after the tests finished is the same file timeout node --test reports.
+    // The process is dirty, so it ends and the next mutant starts clean.
+    if (reply.dirty) process.exit(0)
+  } catch (err) {
+    writeFileSync(job.replyFile, `${JSON.stringify({ id: job.id, pid: process.pid, failed: [], names: [], error: err instanceof Error ? err.message : String(err) })}\n`)
+  } finally {
+    if (!process.stdin.destroyed) process.stdin.ref()
+    lines.resume()
+  }
+}

package/dist/mutate/node-coverage.mjs

@@ -1,200 +1,29 @@
 // Baseline-only per-test line map for node --test. Loaded with --import in each
 // test-file process. Writes one shard; the runner merges shards after the suite.
 // takePreciseCoverage resets counters, so each sample is only what ran since the last take.
+// A plain-script child does not run these hooks. It may leave a nameless hit list in
+// ${map}.children. afterEach stores that list under the parent test before the shard is written.
 import { randomBytes } from "node:crypto"
-import { mkdirSync, writeFileSync } from "node:fs"
-import { Session } from "node:inspector/promises"
-import { findSourceMap } from "node:module"
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
 import { after, afterEach, before } from "node:test"
 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
-}
+import { openLineSampler } from "./precise-lines.mjs"
 
 const mapPath = process.env.PROBATIO_COVERAGE_MAP
 if (mapPath) {
-  const session = new Session()
-  let started = false
+  let sampler = null
   try {
-    session.connect()
-    await session.post("Profiler.enable")
-    await session.post("Debugger.enable")
-    await session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true })
-    started = true
+    sampler = await openLineSampler((rel) => rel.endsWith("node-coverage.mjs") || rel.endsWith("precise-lines.mjs") || rel.endsWith("child-lines.mjs"))
   } catch (err) {
     writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
   }
 
-  if (started) {
-    const textCache = new Map()
-    const indexCache = new Map()
+  if (sampler) {
     /** @type {Map<string, Map<number, Set<string>>>} */
     const byFile = new Map()
     /** @type {Array<{ file: string, line: number }>} */
     let prelude = []
 
-    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 (rel.endsWith("node-coverage.mjs")) 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
-      }
-      // Node 22 reports SourceMap.findEntry originalLine as 0-based.
-      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)
-      }
-      // Outer ranges first. A nested block then overwrites its own offsets, so a dead
-      // branch stays at 0 while a condition earlier on that same line can stay covered.
-      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")
-      /** @type {Array<{ file: string, line: number }>} */
-      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
-    }
-
     function add(hits, name) {
       if (!name) return
       for (const hit of hits) {
@@ -212,9 +41,36 @@ if (mapPath) {
       }
     }
 
+    function takeChildHits() {
+      const dir = `${mapPath}.children`
+      if (!existsSync(dir)) return []
+      /** @type {Array<{ file: string, line: number }>} */
+      const hits = []
+      for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".json")) continue
+        const full = path.join(dir, name)
+        try {
+          const parsed = JSON.parse(readFileSync(full, "utf8"))
+          const list = parsed && Array.isArray(parsed.hits) ? parsed.hits : []
+          for (const hit of list) {
+            if (!hit || typeof hit.file !== "string" || !Number.isInteger(hit.line)) continue
+            hits.push({ file: hit.file, line: hit.line })
+          }
+        } catch {
+          // A torn dump is ignored. The parent does not invent a line.
+        }
+        try {
+          unlinkSync(full)
+        } catch {
+          // The next test must not inherit this dump.
+        }
+      }
+      return hits
+    }
+
     before(async () => {
       try {
-        prelude = await positiveLines()
+        prelude = await sampler.positiveLines()
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
       }
@@ -223,7 +79,8 @@ if (mapPath) {
     afterEach(async (t) => {
       try {
         add(prelude, t.name)
-        add(await positiveLines(), t.name)
+        add(await sampler.positiveLines(), t.name)
+        add(takeChildHits(), t.name)
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
       }

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/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");
@@ -277,9 +304,15 @@ 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);
         }
@@ -404,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);

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

package/dist/mutate/suites.js

@@ -400,8 +400,11 @@ async function launch(pkg, spec, files, pattern, names, timeoutMs, env, hooks) {
     }
     if (spec.kind === "dotnet-exe")
         return tag(runDotnetExe(pkg, spec, files, timeoutMs, env), spec.command, wantsNames, selection);
-    if (spec.kind === "mocha")
-        return tag(runMocha(pkg, files, timeoutMs, env), spec.command, wantsNames, selection);
+    if (spec.kind === "mocha") {
+        const grep = selection.length > 0 ? selection.map(escapeRegExp).join("|") : "";
+        const command = grep ? `${spec.command} --grep ${JSON.stringify(grep)}` : spec.command;
+        return tag(runMocha(pkg, files, timeoutMs, env, selection), command, false, selection);
+    }
     // A tty is only for a suite that runs `docker run -it` (tini). Everything else is bash.
     if (spec.kind === "script") {
         const launched = scriptInvocation(pkg);
@@ -481,18 +484,46 @@ function runShell(pkg, command, timeoutMs, env) {
     const child = /\b(java|javac|mvn)\b/.test(command) ? javaEnv(env) : env;
     return spawnCollected("sh", ["-c", command], pkg, { ...child, PYTHONDONTWRITEBYTECODE: "1" }, timeoutMs);
 }
+/**
+ * Node's `--test-timeout` caps the file, not only a test that left the option unset.
+ * A test that sets a longer `timeout` is cancelled, and the failure name is the file path.
+ * The flag stays at least that long, and it stays inside the suite cap.
+ */
+export function nodeTestTimeoutMs(pkg, files, testTimeoutMs, suiteTimeoutMs) {
+    let declared = 0;
+    for (const rel of files) {
+        let text = "";
+        try {
+            text = readFileSync(path.join(pkg, rel), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const match of text.matchAll(/timeout\s*:\s*(\d[\d_]*)/g)) {
+            const value = Number(match[1].replaceAll("_", ""));
+            if (Number.isFinite(value) && value > declared)
+                declared = value;
+        }
+    }
+    const floor = Number.isFinite(testTimeoutMs) && testTimeoutMs > 0 ? testTimeoutMs : 0;
+    let chosen = Math.max(floor, declared);
+    if (Number.isFinite(suiteTimeoutMs) && suiteTimeoutMs > 0 && chosen > suiteTimeoutMs)
+        chosen = suiteTimeoutMs;
+    return chosen > 0 ? chosen : floor;
+}
 async function runNode(pkg, files, pattern, timeoutMs, env, hooks) {
     const tsx = path.join(pkg, "node_modules", ".bin", "tsx");
     const bin = existsSync(tsx) ? tsx : process.execPath;
     const prefix = existsSync(tsx) ? [] : ["--experimental-strip-types"];
     const hook = env.PROBATIO_COVERAGE_MAP ? fileURLToPath(new URL("./node-coverage.mjs", import.meta.url)) : null;
+    const fileTimeout = nodeTestTimeoutMs(pkg, files, hooks.testTimeoutMs, timeoutMs);
     const result = await spawnCollected(bin, [
         ...prefix,
         ...(hook ? ["--import", hook] : []),
         "--test",
         `--test-reporter=${hooks.reporterPath}`,
         `--test-concurrency=${hooks.concurrency}`,
-        `--test-timeout=${hooks.testTimeoutMs}`,
+        `--test-timeout=${fileTimeout}`,
         ...(pattern ? [`--test-name-pattern=${pattern}`] : []),
         ...files,
     ], pkg, env, timeoutMs);
@@ -545,7 +576,7 @@ function runPython(pkg, files, pattern, timeoutMs, env, script, nodeIds) {
     const targets = nodeIds && nodeIds.length > 0 ? nodeIds : files;
     return spawnCollected("python3", [reporter, ...targets, ...(pattern ? ["--pattern", pattern] : [])], pkg, next, timeoutMs);
 }
-async function runMocha(pkg, files, timeoutMs, env) {
+async function runMocha(pkg, files, timeoutMs, env, names = null) {
     const mocha = ["mocha.js", "mocha"]
         .map((name) => path.join(pkg, "node_modules", "mocha", "bin", name))
         .find((file) => existsSync(file));
@@ -556,6 +587,10 @@ async function runMocha(pkg, files, timeoutMs, env) {
         return prepared;
     const config = readMochaConfig(pkg);
     const args = [mocha, ...buildMochaArgs(pkg, files)];
+    if (names && names.length > 0)
+        args.push("--grep", names.map(escapeRegExp).join("|"));
+    if (env.PROBATIO_COVERAGE_MAP)
+        args.push("--require", fileURLToPath(new URL("./mocha-coverage.cjs", import.meta.url)));
     if (config && config.require.includes("esm")) {
         // The `esm` loader throws on current Node before any test runs. Drop that one require and keep the rest of the project's mocha config.
         const requires = config.require.filter((name) => name !== "esm");

package/dist/verify/change.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { SCHEMA_VERSION } from "../contract.js";
 import { asTable } from "../golden/check.js";
@@ -26,9 +26,10 @@ export async function verifyChange(options) {
     const goldenContract = goldenDiffs(repo, options.base, options.commit, changed);
     const packageFiles = [];
     const chosen = [];
+    const libImported = testsImportLib(packageDir);
     for (const [file, lines] of ranges) {
         const rel = toPackage(prefix, file);
-        if (!rel || !rel.startsWith("src/") || rel.endsWith(".d.ts"))
+        if (!rel || !isVerifySource(rel, packageDir, libImported))
             continue;
         packageFiles.push(rel);
         const text = showFile(repo, options.commit, file);
@@ -269,3 +270,66 @@ function toPackage(prefix, file) {
         return null;
     return file.slice(prefix.length + 1);
 }
+const SKIPPED_SOURCE = new Set(["node_modules", "dist", "docs", "tests", "test"]);
+/** src/, a lib/ tree the tests import, or a Go file beside go.mod. Tests, docs, dist, and node_modules stay out. */
+function isVerifySource(rel, packageDir, libImported) {
+    if (rel.endsWith(".d.ts"))
+        return false;
+    const parts = rel.split("/");
+    if (parts.some((part) => SKIPPED_SOURCE.has(part)))
+        return false;
+    if (rel.startsWith("src/"))
+        return true;
+    if (libImported && rel.startsWith("lib/"))
+        return true;
+    if (!rel.includes("/") && rel.endsWith(".go") && !rel.endsWith("_test.go") && existsSync(path.join(packageDir, "go.mod")))
+        return true;
+    return false;
+}
+function testsImportLib(packageDir) {
+    const pattern = /(?:require\s*\(\s*|from\s+)['"](?:@[^'"]+\/)?(?:\.\.\/|\.\/)*lib\//;
+    for (const dirName of ["tests", "test"]) {
+        const dir = path.join(packageDir, dirName);
+        if (!existsSync(dir))
+            continue;
+        if (walkText(dir).some((text) => pattern.test(text)))
+            return true;
+    }
+    return false;
+}
+function walkText(dir) {
+    const out = [];
+    const visit = (current) => {
+        let entries;
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (name === "node_modules" || name === "dist")
+                continue;
+            const full = path.join(current, name);
+            let info;
+            try {
+                info = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (info.isDirectory())
+                visit(full);
+            else if (info.isFile() && info.size < 1_000_000) {
+                try {
+                    out.push(readFileSync(full, "utf8"));
+                }
+                catch {
+                    // An unreadable test file does not count as an import of lib/.
+                }
+            }
+        }
+    };
+    visit(dir);
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "probatio",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Mutation runner for AI agents. Scores a test suite by the bugs it catches.",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "url": "https://github.com/IronAdamant/Probatio/issues"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
+    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/precise-lines.mjs src/mutate/child-lines.mjs src/mutate/mocha-coverage.cjs src/mutate/node-batch.mjs src/mutate/node-batch-loader.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
     "test": "tsx --test tests/*.test.ts",
     "probatio": "tsx src/cli.ts"
   },