probatio 0.0.5 → 0.1.2

package/README.md

@@ -1,11 +1,11 @@
 # Probatio
 
 Probatio (Latin: a testing, a proof) is a free testing toolkit under the MIT license, built for AI agents
-(Claude, Grok, ChatGPT, others), working alone or as swarms. Every claim it makes is checkable;
-it remembers what was fixed so agents with small context do not redo or undo work; and it finds
-the bugs a test suite would miss instead of asking anyone to read more tests.
+(Claude, Grok, ChatGPT, others), working alone or as swarms. Every claim it makes is checkable.
+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-05): `mutate run` discovers the project suite and scores it. Python, JavaScript, and TypeScript narrow each mutant with a line map collected on the baseline. C does the same when the binary was built with LLVM 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` mutates the changed lines and uses that same map. `mutate tally` reads a finished run, names tests that killed nothing, and does not delete a test. 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.
 
-Python, JavaScript, and TypeScript collect a line map on the baseline. C collects one when LLVM coverage was instrumented. Go and Maven/Java collect file, line, and the test names that hit that line. A later mutant runs only those tests (`go test -run`, Maven `-Dtest`). A line no test executed is `no coverage`, and the suite is not started. Rust and C# can take a test name and do not collect a line. 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/cli.js

@@ -133,6 +133,29 @@ async function generateCommand(flags) {
     };
 }
 async function runCommand(flags, hide = null) {
+    const onlyNames = texts(flags, "only-test");
+    if (onlyNames.some((id) => id === "::command" || id.endsWith("::command"))) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "mutate.run",
+            summary: "::command is not a test id.",
+            next: "Pass a test name the suite can collect.",
+            nextCall: null,
+            killed: 0,
+        };
+    }
+    if (onlyNames.length > 0 && text(flags, "suite-command")) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "mutate.run",
+            summary: "--only-test cannot be combined with --suite-command.",
+            next: "Drop --suite-command and pass the keep ids with --only-test.",
+            nextCall: null,
+            killed: 0,
+        };
+    }
     const packageDir = path.resolve(requireText(flags, "package"));
     const patchDirs = texts(flags, "patches").map((dir) => path.resolve(dir));
     if (patchDirs.length === 0)
@@ -167,6 +190,7 @@ async function runCommand(flags, hide = null) {
         affected: bool(flags, "affected", false),
         agent: text(flags, "agent") ?? null,
         suiteCommand: text(flags, "suite-command") ?? null,
+        onlyNames: onlyNames.length > 0 ? onlyNames : null,
         historyPath: text(flags, "history") ? path.resolve(text(flags, "history")) : null,
         timeoutMultiple: int(flags, "timeout-multiple") ?? 5,
         timeoutFloorMs: int(flags, "timeout-floor-ms") ?? 20_000,

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`)
       }