probatio 0.1.0 → 0.1.3

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")
+    },
+  }
+}