probatio 0.3.0 → 0.5.0

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

@@ -1,99 +0,0 @@
-// 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)
-}
-
-/** TypeScript with NodeNext writes `./limit.js` for `limit.ts`. tsx resolves that, so this loader does too. */
-function typeScriptSibling(specifier) {
-  if (!/^(\.{1,2}\/|\/|file:)/.test(specifier)) return null
-  const swapped = specifier.replace(/\.js$/, ".ts").replace(/\.mjs$/, ".mts").replace(/\.cjs$/, ".cts").replace(/\.jsx$/, ".tsx")
-  return swapped === specifier ? null : swapped
-}
-
-export async function resolve(specifier, context, nextResolve) {
-  let resolved
-  try {
-    resolved = await nextResolve(specifier, context)
-  } catch (error) {
-    const sibling = typeScriptSibling(specifier)
-    if (!sibling) throw error
-    resolved = await nextResolve(sibling, 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

@@ -1,167 +0,0 @@
-// 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 { readFileSync, realpathSync, writeFileSync } from "node:fs"
-import { register } from "node:module"
-import { run } from "node:test"
-import path from "node:path"
-import { errorText, staticLoadFailure } from "./load-failure.mjs"
-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 = []
-  // run() with isolation "none" ignores testNamePatterns on Node 22, so every test in the file runs.
-  // Only a requested test, or a subtest of one, is a result. Another test failing is not a kill.
-  const wanted = new Set((job.names || []).filter((name) => name.length > 0))
-  const stack = []
-  const requested = (name, nesting) =>
-    wanted.size === 0 || wanted.has(name) || stack.slice(0, nesting).some((parent) => wanted.has(parent))
-  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()
-      const data = event.data || {}
-      const nesting = Number.isInteger(data.nesting) ? data.nesting : 0
-      if (event.type === "test:start") {
-        stack.length = nesting
-        stack[nesting] = typeof data.name === "string" ? data.name : ""
-        continue
-      }
-      if (event.type !== "test:pass" && event.type !== "test:fail") continue
-      const name = typeof data.name === "string" ? data.name : ""
-      if (!name) continue
-      if (files.includes(name)) {
-        // The file itself failed: it did not load (a removed export, a throw at import time).
-        // No test in it ran. That is a failure of the file, the same as node --test reports it.
-        if (event.type === "test:fail" && fileHasRequested(name, wanted)) {
-          const posix = path.relative(job.root, name).split(path.sep).join("/")
-          const linked = !staticLoadFailure(errorText(data.details && data.details.error))
-          failed.push({ name: posix, file: name, line: 1, fileLoad: true, ...(linked ? {} : { staticLoad: true }) })
-          if (!names.includes(posix)) names.push(posix)
-        }
-        continue
-      }
-      if (!requested(name, nesting)) 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 }
-}
-
-/** A file with no requested test in it does not speak for the requested tests. */
-function fileHasRequested(file, wanted) {
-  if (wanted.size === 0) return true
-  let text = ""
-  try {
-    text = readFileSync(file, "utf8")
-  } catch {
-    return true
-  }
-  return [...wanted].some((name) => text.includes(name))
-}
-
-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,77 +0,0 @@
-// 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 node child of a test does not run these hooks. exposeChildLines puts child-lines.mjs in
-// its NODE_OPTIONS, so it leaves a nameless hit list in ${map}.children when it exits.
-// 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 { after, afterEach, before } from "node:test"
-import path from "node:path"
-import { exposeChildLines, openLineSampler, takeChildHits } from "./precise-lines.mjs"
-
-const mapPath = process.env.PROBATIO_COVERAGE_MAP
-if (mapPath) {
-  let sampler = null
-  try {
-    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 (sampler) {
-    exposeChildLines()
-    /** @type {Map<string, Map<number, Set<string>>>} */
-    const byFile = new Map()
-    /** @type {Array<{ file: string, line: number }>} */
-    let prelude = []
-
-    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)
-      }
-    }
-
-    before(async () => {
-      try {
-        prelude = await sampler.positiveLines()
-      } catch (err) {
-        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-      }
-    })
-
-    afterEach(async (t) => {
-      try {
-        add(prelude, t.name)
-        add(await sampler.positiveLines(), t.name)
-        add(takeChildHits(mapPath), t.name)
-      } catch (err) {
-        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-      }
-    })
-
-    after(() => {
-      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
-      }
-      const dir = `${mapPath}.parts`
-      mkdirSync(dir, { recursive: true })
-      writeFileSync(path.join(dir, `${process.pid}-${randomBytes(4).toString("hex")}.json`), JSON.stringify({ files }))
-    })
-  }
-}

package/dist/mutate/operators.js

@@ -1,181 +0,0 @@
-import ts from "typescript";
-const ARITHMETIC = {
-    [ts.SyntaxKind.PlusToken]: { op: "add-to-sub", replacement: "-" },
-    [ts.SyntaxKind.MinusToken]: { op: "sub-to-add", replacement: "+" },
-    [ts.SyntaxKind.AsteriskToken]: { op: "mul-to-div", replacement: "/" },
-    [ts.SyntaxKind.SlashToken]: { op: "div-to-mul", replacement: "*" },
-    [ts.SyntaxKind.PercentToken]: { op: "mod-to-mul", replacement: "*" },
-};
-const SWAP = {
-    [ts.SyntaxKind.AmpersandAmpersandToken]: { op: "and-to-or", replacement: "||" },
-    [ts.SyntaxKind.BarBarToken]: { op: "or-to-and", replacement: "&&" },
-    [ts.SyntaxKind.EqualsEqualsEqualsToken]: { op: "eq-to-neq", replacement: "!==" },
-    [ts.SyntaxKind.ExclamationEqualsEqualsToken]: { op: "neq-to-eq", replacement: "===" },
-    [ts.SyntaxKind.LessThanToken]: { op: "lt-to-le", replacement: "<=" },
-    [ts.SyntaxKind.LessThanEqualsToken]: { op: "le-to-lt", replacement: "<" },
-    [ts.SyntaxKind.GreaterThanToken]: { op: "gt-to-ge", replacement: ">=" },
-    [ts.SyntaxKind.GreaterThanEqualsToken]: { op: "ge-to-gt", replacement: ">" },
-};
-/**
- * Operator mutants in code only. Strings, comments, and type positions are not code.
- * A condition that contains a string (`name === "x"`) is still code: the span is not
- * itself inside the string.
- */
-export function findMutants(file, text, operators = "core") {
-    const scriptKind = file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-    const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind);
-    const raw = [];
-    const visit = (node) => {
-        if (isTypePosition(node))
-            return;
-        const point = pointAt(source, file, text, node);
-        if (point)
-            raw.push(point);
-        if (operators === "wide") {
-            const extra = widePointAt(source, file, text, node);
-            if (extra)
-                raw.push(extra);
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(source);
-    const hidden = hiddenSpans(source, text, scriptKind);
-    const points = [];
-    const violations = [];
-    for (const point of raw) {
-        const inside = hidden.some((span) => point.start >= span.start && point.end <= span.end);
-        if (inside)
-            violations.push(point);
-        else
-            points.push(point);
-    }
-    return { points, violations };
-}
-function isTypePosition(node) {
-    return (ts.isTypeNode(node) ||
-        ts.isTypeAliasDeclaration(node) ||
-        ts.isInterfaceDeclaration(node) ||
-        ts.isTypeParameterDeclaration(node) ||
-        ts.isIndexSignatureDeclaration(node));
-}
-function pointAt(source, file, text, node) {
-    if (ts.isIfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) {
-        return negate(source, file, text, node.expression, "negate-condition");
-    }
-    if (ts.isConditionalExpression(node)) {
-        return negate(source, file, text, node.condition, "negate-ternary");
-    }
-    if (ts.isForStatement(node) && node.condition) {
-        return negate(source, file, text, node.condition, "negate-condition");
-    }
-    if (ts.isBinaryExpression(node)) {
-        const swap = SWAP[node.operatorToken.kind];
-        if (!swap)
-            return undefined;
-        const start = node.operatorToken.getStart(source);
-        const end = node.operatorToken.getEnd();
-        return make(source, file, text, start, end, swap.op, swap.replacement);
-    }
-    if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
-        const start = node.getStart(source);
-        const end = node.getEnd();
-        const original = text.slice(start, end);
-        const replacement = original === "true" ? "false" : "true";
-        const op = original === "true" ? "true-to-false" : "false-to-true";
-        return make(source, file, text, start, end, op, replacement);
-    }
-    if (ts.isPrefixUnaryExpression(node) &&
-        node.operator === ts.SyntaxKind.ExclamationToken &&
-        !ts.isPrefixUnaryExpression(node.operand)) {
-        const start = node.getStart(source);
-        const end = node.operand.getStart(source);
-        return make(source, file, text, start, end, "drop-not", "");
-    }
-    return undefined;
-}
-/** Arithmetic, constants, and a dropped call. Only in the wide set. */
-function widePointAt(source, file, text, node) {
-    if (ts.isBinaryExpression(node)) {
-        const swap = ARITHMETIC[node.operatorToken.kind];
-        if (!swap)
-            return undefined;
-        // `"a" + n` builds a string. Swapping it for `-` changes the type, not the arithmetic.
-        if (node.operatorToken.kind === ts.SyntaxKind.PlusToken && (stringish(node.left) || stringish(node.right)))
-            return undefined;
-        const start = node.operatorToken.getStart(source);
-        return make(source, file, text, start, node.operatorToken.getEnd(), swap.op, swap.replacement);
-    }
-    if (ts.isNumericLiteral(node) && /^\d+$/.test(node.text) && node.getText(source) === node.text) {
-        // A property name or an enum key written as a number is a name, not a value.
-        if (ts.isPropertyAssignment(node.parent) && node.parent.name === node)
-            return undefined;
-        if (ts.isEnumMember(node.parent) && node.parent.name === node)
-            return undefined;
-        const start = node.getStart(source);
-        const value = node.text;
-        if (value === "0")
-            return make(source, file, text, start, node.getEnd(), "const-zero-to-one", "1");
-        if (value === "1")
-            return make(source, file, text, start, node.getEnd(), "const-one-to-zero", "0");
-        if (value.length <= 15)
-            return make(source, file, text, start, node.getEnd(), "const-inc", String(Number(value) + 1));
-        return undefined;
-    }
-    if (ts.isExpressionStatement(node) && ts.isBlock(node.parent)) {
-        const call = ts.isAwaitExpression(node.expression) ? node.expression.expression : node.expression;
-        if (!ts.isCallExpression(call) || call.expression.kind === ts.SyntaxKind.SuperKeyword)
-            return undefined;
-        // `void 0` keeps the statement valid wherever it stands. The call and its effects are gone.
-        const start = node.expression.getStart(source);
-        return make(source, file, text, start, node.expression.getEnd(), "drop-call", "void 0");
-    }
-    return undefined;
-}
-function stringish(node) {
-    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isTemplateExpression(node))
-        return true;
-    if (ts.isParenthesizedExpression(node))
-        return stringish(node.expression);
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken)
-        return stringish(node.left) || stringish(node.right);
-    return false;
-}
-function negate(source, file, text, expr, op) {
-    const start = expr.getStart(source);
-    const end = expr.getEnd();
-    return make(source, file, text, start, end, op, `!(${text.slice(start, end)})`);
-}
-function make(source, file, text, start, end, op, replacement) {
-    const { line } = source.getLineAndCharacterOfPosition(start);
-    return { file, start, end, line: line + 1, op, original: text.slice(start, end), replacement };
-}
-function hiddenSpans(source, text, scriptKind) {
-    const literals = [];
-    const visit = (node) => {
-        if (ts.isStringLiteral(node) ||
-            ts.isNoSubstitutionTemplateLiteral(node) ||
-            ts.isTemplateHead(node) ||
-            ts.isTemplateMiddle(node) ||
-            ts.isTemplateTail(node) ||
-            ts.isRegularExpressionLiteral(node) ||
-            ts.isJsxText(node)) {
-            literals.push({ start: node.getStart(source), end: node.getEnd() });
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(source);
-    const variant = scriptKind === ts.ScriptKind.TSX ? ts.LanguageVariant.JSX : ts.LanguageVariant.Standard;
-    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, variant, text);
-    const comments = [];
-    let token = scanner.scan();
-    while (token !== ts.SyntaxKind.EndOfFileToken) {
-        const leading = ts.getLeadingCommentRanges(text, scanner.getTokenStart()) ?? [];
-        const trailing = ts.getTrailingCommentRanges(text, scanner.getTokenEnd()) ?? [];
-        for (const comment of [...leading, ...trailing])
-            comments.push({ start: comment.pos, end: comment.end });
-        token = scanner.scan();
-    }
-    // A `//` inside a template is text, not a comment. Drop ranges that begin in a literal.
-    const real = comments.filter((comment) => !literals.some((span) => comment.start >= span.start && comment.start < span.end));
-    return [...literals, ...real];
-}

package/dist/mutate/patch.js

@@ -1,136 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-export function readHeader(raw) {
-    const lines = raw.split(/\r?\n/);
-    let direction = null;
-    let index = 0;
-    while (index < lines.length && !lines[index].startsWith("---") && !lines[index].startsWith("diff ")) {
-        const match = lines[index].match(/direction=(forward|reverse)/);
-        if (match)
-            direction = match[1];
-        index++;
-    }
-    const body = lines.slice(index).join("\n");
-    return { direction, body: body.endsWith("\n") || body.length === 0 ? body : `${body}\n` };
-}
-/** `diff -u` patch that applies onto the original and produces the mutant. */
-export function forwardDiff(rel, original, mutated) {
-    const dir = mkdtempSync(path.join(tmpdir(), "probatio-diff-"));
-    try {
-        const before = path.join(dir, "before");
-        const after = path.join(dir, "after");
-        writeFileSync(before, original);
-        writeFileSync(after, mutated);
-        const diff = spawnSync("diff", ["-u", "-L", `a/${rel}`, "-L", `b/${rel}`, before, after], { encoding: "utf8" });
-        if (diff.status === 0)
-            return "";
-        if (diff.status !== 1)
-            throw new Error(diff.stderr.trim() || "diff failed");
-        const body = diff.stdout.endsWith("\n") ? diff.stdout : `${diff.stdout}\n`;
-        return `# probatio-mutant direction=forward meaning=apply-to-introduce-the-bug\n${body}`;
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-export function filesInDiff(raw) {
-    const body = readHeader(raw).body;
-    const files = [];
-    const chunks = body.split(/^diff --git .*$/m);
-    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
-    for (const piece of pieces) {
-        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
-        const hunk = piece.match(/^@@ -\d+(?:,\d+)? \+(\d+)/m);
-        if (!plus)
-            continue;
-        let file = plus[1];
-        if (file === "/dev/null")
-            continue;
-        // git diff -R swaps the labels, so the path may be a/ or b/.
-        if (file.startsWith("a/") || file.startsWith("b/"))
-            file = file.slice(2);
-        files.push({ file, line: hunk ? Number(hunk[1]) : 1 });
-    }
-    return files;
-}
-/**
- * Original lines a patch removes or replaces.
- * A unified hunk starts on context, so the hunk header is not the edited line.
- */
-export function changedLines(raw) {
-    const body = readHeader(raw).body;
-    const chunks = body.split(/^diff --git .*$/m);
-    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
-    const found = [];
-    for (const piece of pieces) {
-        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
-        if (!plus)
-            continue;
-        let file = plus[1];
-        if (file === "/dev/null")
-            continue;
-        if (file.startsWith("a/") || file.startsWith("b/"))
-            file = file.slice(2);
-        let oldLine = 0;
-        let inHunk = false;
-        for (const line of piece.split(/\r?\n/)) {
-            const hunk = /^@@ -(\d+)(?:,\d+)? \+\d+/.exec(line);
-            if (hunk) {
-                oldLine = Number(hunk[1]);
-                inHunk = true;
-                continue;
-            }
-            if (!inHunk)
-                continue;
-            if (line.startsWith("+") || line.startsWith("\\"))
-                continue;
-            if (line.startsWith("-")) {
-                found.push({ file, line: oldLine });
-                oldLine += 1;
-                continue;
-            }
-            if (line.startsWith(" ")) {
-                oldLine += 1;
-                continue;
-            }
-            inHunk = false;
-        }
-    }
-    return found;
-}
-export function git(repo, args, input) {
-    const result = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8", input });
-    const stderr = [result.stderr ?? "", result.error?.message ?? ""].filter((part) => part.length > 0).join("\n");
-    return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr };
-}
-export function patchApplies(repo, raw, direction) {
-    const args = ["apply", "--check", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
-    return git(repo, args, readHeader(raw).body).status === 0;
-}
-export function chooseDirection(repo, raw, requested) {
-    if (requested !== "auto")
-        return requested;
-    const header = readHeader(raw).direction;
-    if (header)
-        return header;
-    if (patchApplies(repo, raw, "forward"))
-        return "forward";
-    if (patchApplies(repo, raw, "reverse"))
-        return "reverse";
-    return null;
-}
-export function applyPatch(repo, raw, direction) {
-    const args = ["apply", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
-    const result = git(repo, args, readHeader(raw).body);
-    if (result.status === 0)
-        return { ok: true };
-    return { ok: false, error: (result.stderr || result.stdout).trim() || "apply failed" };
-}
-/** Put a throwaway worktree back. A diff label is not trusted for the path list. */
-export function restoreTree(repo) {
-    git(repo, ["checkout", "--", "."]);
-    // .probatio.json may be the user's uncommitted copy, put there when the worktree was made.
-    git(repo, ["clean", "-fd", "-e", "node_modules", "-e", ".probatio.json"]);
-}