probatio 0.1.3 → 0.3.0

package/dist/mcp.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -7,7 +7,7 @@ import { nodeTooOld } from "./node-version.js";
 const tooOld = nodeTooOld(process.versions.node);
 if (tooOld) {
     process.stdout.write(`${JSON.stringify({
-        schemaVersion: 1,
+        schemaVersion: 2,
         ok: false,
         command: "mcp",
         summary: tooOld,
@@ -16,6 +16,8 @@ if (tooOld) {
     })}\n`);
     process.exit(1);
 }
+/** Protocol versions this server speaks. The client's choice wins when it is one of these. */
+const PROTOCOLS = ["2024-11-05", "2025-03-26", "2025-06-18"];
 const here = path.dirname(fileURLToPath(import.meta.url));
 const version = readVersion();
 const tool = {
@@ -28,6 +30,9 @@ const tool = {
     },
 };
 let buffer = "";
+let closing = false;
+/** Tool calls still running, by request id. A cancel kills the child and drops the reply. */
+const running = new Map();
 process.stdin.setEncoding("utf8");
 process.stdin.on("data", (chunk) => {
     buffer += chunk;
@@ -35,7 +40,10 @@ process.stdin.on("data", (chunk) => {
 });
 process.stdin.on("end", () => {
     drain(true);
-    process.exit(0);
+    closing = true;
+    // A call already running still gets its reply before the server exits.
+    if (running.size === 0)
+        process.exit(0);
 });
 function drain(flush = false) {
     const lines = buffer.split("\n");
@@ -57,6 +65,22 @@ function drain(flush = false) {
 function handle(message) {
     if (!message.method)
         return;
+    if (message.method === "notifications/cancelled") {
+        const key = message.params?.requestId;
+        if (key === undefined)
+            return;
+        const child = running.get(String(key));
+        running.delete(String(key));
+        if (child?.pid) {
+            try {
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch {
+                child.kill("SIGTERM");
+            }
+        }
+        return;
+    }
     if (message.id === undefined || message.id === null)
         return;
     if (message.method === "initialize") {
@@ -64,7 +88,7 @@ function handle(message) {
             jsonrpc: "2.0",
             id: message.id,
             result: {
-                protocolVersion: "2024-11-05",
+                protocolVersion: PROTOCOLS.includes(message.params?.protocolVersion ?? "") ? message.params?.protocolVersion : PROTOCOLS[0],
                 capabilities: { tools: {} },
                 serverInfo: { name: "probatio", version },
                 tools: [tool],
@@ -86,29 +110,7 @@ function handle(message) {
             send({ jsonrpc: "2.0", id: message.id, error: { code: -32602, message: "argv must be an array of strings" } });
             return;
         }
-        const cli = cliCommand();
-        const child = spawnSync(cli.bin, [...cli.args, ...argv], { encoding: "utf8" });
-        const text = child.stdout ?? "";
-        let envelope = null;
-        try {
-            envelope = JSON.parse(text);
-        }
-        catch {
-            envelope = null;
-        }
-        if (!envelope || typeof envelope !== "object") {
-            send({ jsonrpc: "2.0", id: message.id, error: { code: -32000, message: "the command did not return one JSON object" } });
-            return;
-        }
-        send({
-            jsonrpc: "2.0",
-            id: message.id,
-            result: {
-                content: [{ type: "text", text: text.trim() }],
-                structuredContent: envelope,
-                isError: envelope.ok !== true,
-            },
-        });
+        call(message.id, argv);
         return;
     }
     send({
@@ -117,6 +119,53 @@ function handle(message) {
         error: { code: -32601, message: `method not found: ${message.method}` },
     });
 }
+/** One CLI command per call. It runs beside other calls, so ping and cancel are answered meanwhile. */
+function call(id, argv) {
+    const key = String(id);
+    const cli = cliCommand();
+    // Its own process group, so a cancel also stops the suite the command started.
+    const child = spawn(cli.bin, [...cli.args, ...argv], { stdio: ["ignore", "pipe", "ignore"], detached: true });
+    running.set(key, child);
+    let text = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        text += chunk;
+    });
+    const settle = (failure) => {
+        // A cancelled call is no longer in the map. Its reply is dropped.
+        const live = running.get(key) === child;
+        running.delete(key);
+        if (live)
+            reply(id, text, failure);
+        if (closing && running.size === 0)
+            process.exit(0);
+    };
+    child.on("error", (error) => settle(error.message));
+    child.on("close", () => settle(null));
+}
+function reply(id, text, failure) {
+    let envelope = null;
+    try {
+        envelope = JSON.parse(text);
+    }
+    catch {
+        envelope = null;
+    }
+    if (!envelope || typeof envelope !== "object") {
+        const message = failure ? `the command did not start: ${failure}` : "the command did not return one JSON object";
+        send({ jsonrpc: "2.0", id, error: { code: -32000, message } });
+        return;
+    }
+    send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+            content: [{ type: "text", text: text.trim() }],
+            structuredContent: envelope,
+            isError: envelope.ok !== true,
+        },
+    });
+}
 function cliCommand() {
     const compiled = path.join(here, "cli.js");
     if (existsSync(compiled))

package/dist/mutate/child-lines.mjs

@@ -1,34 +1,39 @@
-// Nameless line dump for a plain script. This is not a node:test process and it
+// Nameless line dump for a node child of a test. This is not a node:test process and it
 // does not write a coverage shard. The parent test's afterEach reads the dump.
+// The test-process collector puts this file in NODE_OPTIONS, so the child needs no import.
+// The dump is written on `exit`, which also runs after process.exit(), so it is synchronous.
 import { randomBytes } from "node:crypto"
 import { mkdirSync, writeFileSync } from "node:fs"
 import path from "node:path"
-import { openLineSampler } from "./precise-lines.mjs"
+import { openSyncLineSampler } from "./precise-lines.mjs"
 
 const mapPath = process.env.PROBATIO_COVERAGE_MAP
-if (mapPath) {
+if (mapPath && !globalThis.__probatioChildLines) {
+  globalThis.__probatioChildLines = true
   let sampler = null
   try {
-    sampler = await openLineSampler((rel) => rel.endsWith("child-lines.mjs") || rel.endsWith("precise-lines.mjs"))
+    sampler = openSyncLineSampler(
+      (rel) => rel.endsWith("child-lines.mjs") || rel.endsWith("precise-lines.mjs"),
+      process.env.PROBATIO_PACKAGE_ROOT || process.cwd(),
+    )
   } 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`
+    process.on("exit", () => {
+      // A node:test process that loaded this through an inherited NODE_OPTIONS has its own
+      // hooks. Its hits are already named. A nameless dump would land on the wrong test.
+      if (globalThis.__probatioTestHooks) return
+      try {
+        const hits = sampler.positiveLines()
+        // A child started by a mapped test writes where that test's process reads.
+        // A child that was not (a script that imports this file itself) uses the shared dir.
+        const dir = process.env.PROBATIO_CHILD_DIR || `${mapPath}.children`
         mkdirSync(dir, { recursive: true })
-        writeFileSync(
-          path.join(dir, `${process.pid}-${randomBytes(4).toString("hex")}.json`),
-          JSON.stringify({ hits }),
-        )
-      }).catch((err) => {
+        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/fail-reporter.mjs

@@ -1,12 +1,21 @@
 // node --test custom reporter. One JSON object on stdout: failures with the file
 // the runner itself recorded. TAP headings are not used.
+import { staticLoadFailure } from "./load-failure.mjs"
+
 export default async function* reporter(source) {
+  // A file that fails to load prints its error on stderr before the file-level failure.
+  const stderr = new Map()
   const failed = []
   const names = []
   let tests = 0
   let pass = 0
   let fail = 0
   for await (const event of source) {
+    if (event.type === "test:stderr") {
+      const key = String(event.data?.file ?? "")
+      stderr.set(key, `${stderr.get(key) ?? ""}${String(event.data?.message ?? "")}`)
+      continue
+    }
     if (event.type === "test:pass" || event.type === "test:fail") {
       const data = event.data ?? {}
       if (data.details && data.details.type === "suite") continue
@@ -18,6 +27,12 @@ export default async function* reporter(source) {
         // An open handle is reported as a timeout whose name is the file path.
         // failureType lives on the error; the text is on error.cause, not message.
         if (fileTimedOut(name, file, data.details?.error)) failure.fileTimeout = true
+        // The file itself failed and no test in it ran: it did not load.
+        else if (isFileName(name, file)) {
+          failure.fileLoad = true
+          // It did not link (removed export, missing module, no parse): no test code ran.
+          if (staticLoadFailure(stderr.get(file) ?? "")) failure.staticLoad = true
+        }
         failed.push(failure)
       }
     } else if (event.type === "test:diagnostic") {
@@ -33,6 +48,12 @@ export default async function* reporter(source) {
   yield JSON.stringify({ tests, pass, fail, failed, names })
 }
 
+function isFileName(name, file) {
+  const base = String(file).split(/[/\\]/).pop()
+  if (!base) return false
+  return name === file || name === base || name.endsWith(`/${base}`) || name.endsWith(`\\${base}`)
+}
+
 function fileTimedOut(name, file, error) {
   if (!error || typeof error !== "object") return false
   const cause = typeof error.cause === "string" ? error.cause : ""

package/dist/mutate/find.js

@@ -1,10 +1,10 @@
 import { findMutants } from "./operators.js";
 import { findTextMutants, textKind } from "./text-operators.js";
 /** TypeScript stays on the TypeScript parser. Every other recognized source uses its own finder. */
-export function findInSource(file, text) {
+export function findInSource(file, text, operators = "core") {
     if (textKind(file))
-        return findTextMutants(file, text);
-    return findMutants(file, text);
+        return findTextMutants(file, text, operators);
+    return findMutants(file, text, operators);
 }
 export function isGeneratedSource(name) {
     if (textKind(name))

package/dist/mutate/generate.js

@@ -32,7 +32,7 @@ export function generateMutants(options) {
         source = loaded.source;
         const text = loaded.text;
         const rel = posix(path.relative(options.packageDir, file));
-        const found = findInSource(rel, text);
+        const found = findInSource(rel, text, options.operators ?? "core");
         violations.push(...found.violations);
         const ordered = shuffle(found.points, rng);
         const slice = options.perFile === null ? ordered.slice(options.skip) : ordered.slice(options.skip, options.skip + options.perFile);
@@ -60,7 +60,7 @@ export function generateMutants(options) {
         writeFileSync(path.join(mutantsDir, patch), diff);
         mutants.push({ id, file: item.rel, line: item.point.line, op: item.point.op, patch });
     }
-    writeFileSync(path.join(mutantsDir, "mutants.json"), `${JSON.stringify({ schemaVersion: 1, seed: options.seed, mutants }, null, 2)}\n`);
+    writeFileSync(path.join(mutantsDir, "mutants.json"), `${JSON.stringify({ schemaVersion: 1, seed: options.seed, operators: options.operators ?? "core", mutants }, null, 2)}\n`);
     return { mutants, violations, filesVisited, budgetHit, source };
 }
 function fileText(packageDir, absFile, options) {
@@ -81,6 +81,9 @@ function fileText(packageDir, absFile, options) {
 function walkSources(dir, over) {
     if (!statExists(dir))
         return { files: [], stopped: false };
+    // `--src src/text.ts` mutates that one file.
+    if (statSync(dir).isFile())
+        return { files: isSource(path.basename(dir)) ? [dir] : [], stopped: false };
     const out = [];
     let stopped = false;
     const walk = (current) => {

package/dist/mutate/load-failure.mjs

@@ -0,0 +1,40 @@
+// A test file that failed before any test ran either did not link or threw while loading.
+// Did not link: a removed export, a missing module, a file that does not parse. No code ran.
+// A compiled language rejects the same change at compile time, so that mutant is unviable.
+// Threw while loading: the file's own top-level code ran the program and it broke. That is a kill.
+
+const STATIC_ERROR = /^(?:SyntaxError|(?:Type)?Error \[ERR_(?:MODULE_NOT_FOUND|UNKNOWN_FILE_EXTENSION|UNSUPPORTED_DIR_IMPORT|PACKAGE_PATH_NOT_EXPORTED)\]):/
+
+/**
+ * `text` is the error as printed: a `Name: message` line, then `at` frames.
+ * Static when the error is a link or parse error and no frame is in the project's own code.
+ * A SyntaxError thrown by running code (JSON.parse at the top of a test) has a frame in that file.
+ */
+export function staticLoadFailure(text) {
+  const lines = String(text).split(/\r?\n/)
+  const head = lines.findIndex((line) => STATIC_ERROR.test(line.trim()))
+  if (head === -1) return false
+  for (const raw of lines.slice(head + 1)) {
+    const line = raw.trim()
+    if (!line.startsWith("at ")) break
+    if (projectFrame(line)) return false
+  }
+  return true
+}
+
+/** The error object a node:test event carries, printed the way node prints it. */
+export function errorText(error) {
+  if (!error || typeof error !== "object") return ""
+  const name = typeof error.name === "string" ? error.name : "Error"
+  const code = typeof error.code === "string" ? ` [${error.code}]` : ""
+  const message = typeof error.message === "string" ? error.message : ""
+  const stack = typeof error.stack === "string" ? error.stack.split("\n").slice(1).join("\n") : ""
+  return `${name}${code}: ${message}\n${stack}`
+}
+
+function projectFrame(frame) {
+  if (/\bnode:/.test(frame) || frame.includes("<anonymous>")) return false
+  const location = /(?:file:\/\/)?(\/[^\s)]+|[A-Za-z]:\\[^\s)]+):\d+:\d+\)?$/.exec(frame)
+  if (!location) return false
+  return !location[1].split(/[\\/]/).includes("node_modules")
+}

package/dist/mutate/mocha-coverage.cjs

@@ -12,6 +12,8 @@ if (mapPath) {
   let prelude = []
   /** @type {{ positiveLines: () => Promise<Array<{ file: string, line: number }>> } | null} */
   let sampler = null
+  /** @type {((mapPath: string) => Array<{ file: string, line: number }>) | null} */
+  let takeChildHits = null
 
   function add(hits, name) {
     if (!name) return
@@ -40,7 +42,10 @@ if (mapPath) {
     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"))
+        sampler = await opened.openLineSampler((rel) => rel.endsWith("mocha-coverage.cjs") || rel.endsWith("precise-lines.mjs") || rel.endsWith("node-coverage.mjs") || rel.endsWith("child-lines.mjs"))
+        // A node child of a Mocha test is mapped under that test, the same as under node:test.
+        opened.exposeChildLines()
+        takeChildHits = opened.takeChildHits
         prelude = await sampler.positiveLines()
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
@@ -52,6 +57,7 @@ if (mapPath) {
       try {
         add(prelude, title)
         add(await sampler.positiveLines(), title)
+        if (takeChildHits) add(takeChildHits(mapPath), title)
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
       }

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

@@ -40,8 +40,22 @@ function underPackage(abs) {
   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) {
-  const resolved = await nextResolve(specifier, context)
+  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

package/dist/mutate/node-batch.mjs

@@ -1,10 +1,11 @@
 // 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 { 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
@@ -33,6 +34,12 @@ async function runJob(job) {
   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,
@@ -47,10 +54,28 @@ async function runJob(job) {
   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 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 || files.includes(name)) continue
+      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
@@ -101,6 +126,18 @@ async function runJob(job) {
   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

package/dist/mutate/node-coverage.mjs

@@ -1,13 +1,14 @@
 // 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.
+// 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 { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { mkdirSync, writeFileSync } from "node:fs"
 import { after, afterEach, before } from "node:test"
 import path from "node:path"
-import { openLineSampler } from "./precise-lines.mjs"
+import { exposeChildLines, openLineSampler, takeChildHits } from "./precise-lines.mjs"
 
 const mapPath = process.env.PROBATIO_COVERAGE_MAP
 if (mapPath) {
@@ -19,6 +20,7 @@ if (mapPath) {
   }
 
   if (sampler) {
+    exposeChildLines()
     /** @type {Map<string, Map<number, Set<string>>>} */
     const byFile = new Map()
     /** @type {Array<{ file: string, line: number }>} */
@@ -41,33 +43,6 @@ 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 sampler.positiveLines()
@@ -80,7 +55,7 @@ if (mapPath) {
       try {
         add(prelude, t.name)
         add(await sampler.positiveLines(), t.name)
-        add(takeChildHits(), t.name)
+        add(takeChildHits(mapPath), t.name)
       } catch (err) {
         writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
       }

package/dist/mutate/operators.js

@@ -1,4 +1,11 @@
 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: "&&" },
@@ -14,7 +21,7 @@ const SWAP = {
  * A condition that contains a string (`name === "x"`) is still code: the span is not
  * itself inside the string.
  */
-export function findMutants(file, text) {
+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 = [];
@@ -24,6 +31,11 @@ export function findMutants(file, text) {
         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);
@@ -81,6 +93,53 @@ function pointAt(source, file, text, node) {
     }
     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();

package/dist/mutate/patch.js

@@ -131,5 +131,6 @@ export function applyPatch(repo, raw, direction) {
 /** Put a throwaway worktree back. A diff label is not trusted for the path list. */
 export function restoreTree(repo) {
     git(repo, ["checkout", "--", "."]);
-    git(repo, ["clean", "-fd", "-e", "node_modules"]);
+    // .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"]);
 }