@t09tanaka/test-gates 0.3.3 → 0.4.0

package/dist/cli.js

@@ -1,19 +1,38 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // src/core/args.ts
-var COMMANDS = ["check", "mutation", "mutation-result", "selfcheck", "lcov"];
+var COMMANDS = [
+  "check",
+  "mutation",
+  "mutation-result",
+  "selfcheck",
+  "lcov",
+  "doctor"
+];
 var UsageError = class extends Error {
 };
-var VALUE_OPTIONS = ["--dir", "--report", "--file"];
+var VALUE_OPTIONS = ["--dir", "--report", "--file", "--gate", "--shard", "--jobs"];
+function parseShard(value) {
+  const match = /^([1-9]\d*)\/([1-9]\d*)$/.exec(value);
+  const index = Number(match?.[1]);
+  const total = Number(match?.[2]);
+  if (!Number.isSafeInteger(total) || index > total) {
+    throw new UsageError(
+      `--shard needs <index>/<total> with 1 <= index <= total (for example 2/4), got ${value}`
+    );
+  }
+  return { index, total };
+}
 var OPTIONS_BY_COMMAND = {
   check: ["--dir"],
-  mutation: ["--dir"],
+  mutation: ["--dir", "--gate", "--affected"],
   "mutation-result": ["--dir", "--report"],
-  selfcheck: ["--dir", "--all", "--first"],
-  lcov: ["--dir", "--file"]
+  selfcheck: ["--dir", "--all", "--first", "--gate", "--shard", "--quick", "--jobs"],
+  lcov: ["--dir", "--file"],
+  doctor: ["--dir"]
 };
 function consume(parsed, argv, index, allowed) {
   const arg = argv[index];
@@ -41,13 +60,35 @@ function consume(parsed, argv, index, allowed) {
       if (value === void 0 || value === "") {
         throw new UsageError(`${name} needs a value`);
       }
-      const key = name.slice(2);
-      parsed[key] = value;
+      if (name === "--gate") {
+        parsed.gates.push(value);
+      } else if (name === "--jobs") {
+        if (!/^[1-9]\d{0,2}$/.test(value)) {
+          throw new UsageError(`--jobs needs a number from 1 to 999, got ${value}`);
+        }
+        parsed.jobs = Number(value);
+      } else if (name === "--shard") {
+        if (parsed.shard !== null) {
+          throw new UsageError("--shard can be given only once");
+        }
+        parsed.shard = parseShard(value);
+      } else {
+        const key = name.slice(2);
+        parsed[key] = value;
+      }
       return equals !== -1 ? next : next + 1;
     }
     if (equals !== -1) {
       throw new UsageError(`${name} does not take a value`);
     }
+    if (name === "--quick") {
+      parsed.quick = true;
+      return next;
+    }
+    if (name === "--affected") {
+      parsed.affected = true;
+      return next;
+    }
     const mode = name === "--all" ? "all" : "first";
     if (parsed.mode !== null && parsed.mode !== mode) {
       throw new UsageError("--all and --first cannot be combined");
@@ -72,6 +113,11 @@ function parseArgs(argv) {
     report: null,
     file: null,
     mode: null,
+    gates: [],
+    shard: null,
+    quick: false,
+    affected: false,
+    jobs: null,
     rest: []
   };
   let index = 0;
@@ -87,6 +133,31 @@ function parseArgs(argv) {
   while (index < argv.length) {
     index = consume(parsed, argv, index, allowed);
   }
+  const selections = [
+    parsed.mode === null ? null : `--${parsed.mode}`,
+    parsed.gates.length > 0 ? "--gate" : null,
+    parsed.shard === null ? null : "--shard"
+  ].filter((option) => option !== null);
+  if (selections.length > 1) {
+    throw new UsageError(`${selections.join(" and ")} cannot be combined`);
+  }
+  if (parsed.affected && parsed.gates.length > 0) {
+    throw new UsageError(
+      "--affected and --gate cannot be combined: --gate runs the gates it names, --affected decides which gates run"
+    );
+  }
+  const misplaced = parsed.rest.find((arg) => /^--(gate|shard|quick|jobs)(=|$)/.test(arg));
+  if (parsed.command === "selfcheck" && misplaced !== void 0) {
+    throw new UsageError(
+      `${misplaced.split("=")[0]} after "--" would go to the gate command. Write it before "--"`
+    );
+  }
+  const forStryker = parsed.rest.find((arg) => /^--(gate|affected)(=|$)/.test(arg));
+  if (forStryker !== void 0) {
+    throw new UsageError(
+      `${forStryker.split("=")[0]} after "--" would go to Stryker. Write it before "--"`
+    );
+  }
   if (parsed.command === "selfcheck" && parsed.rest.length === 0 && argv.includes("--")) {
     throw new UsageError('"--" must be followed by the gate command');
   }
@@ -559,19 +630,22 @@ function vitestCoverageViolation(input) {
 // src/fs.ts
 import fs from "fs";
 import path from "path";
-function existsExact(rootDir, relativePath, kind = "file") {
+function existsExact(rootDir, relativePath, kind = "file", listing = /* @__PURE__ */ new Map()) {
   let current = rootDir;
   for (const segment of relativePath.split("/")) {
     if (segment === "" || segment === ".") {
       continue;
     }
-    let entries;
-    try {
-      entries = fs.readdirSync(current);
-    } catch {
-      return false;
+    let entries = listing.get(current);
+    if (entries === void 0) {
+      try {
+        entries = fs.readdirSync(current);
+      } catch {
+        entries = null;
+      }
+      listing.set(current, entries);
     }
-    if (!entries.includes(segment)) {
+    if (entries === null || !entries.includes(segment)) {
       return false;
     }
     current = path.join(current, segment);
@@ -927,6 +1001,7 @@ function resolveSettings(raw) {
 
 // src/core/selfcheck.ts
 var EXCLUDE_ENV = "TEST_GATES_EXCLUDE_SPEC";
+var EXCLUDE_ALL_ENV = "TEST_GATES_EXCLUDE_SPECS";
 var THRESHOLD_MESSAGE = /threshold|coverage data for/i;
 function escapeRegExp2(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -946,6 +1021,197 @@ function judgeSelfcheck(input) {
   const reported = output.split("\n").some((line) => line.includes(gatePath) && THRESHOLD_MESSAGE.test(line));
   return reported ? null : `the gate failed (exit ${status}) but not on the coverage threshold of ${gatePath}. It may be failing for another reason`;
 }
+function selectControls(input) {
+  const { gates, mode, only, shard } = input;
+  if (only.length > 0) {
+    const unknown = only.filter((path13) => !gates.includes(path13));
+    if (unknown.length > 0) {
+      return {
+        error: `--gate ${unknown.join(", ")}: not a gate of test-gates.json (write the path as it is written there)`
+      };
+    }
+    return { selected: gates.filter((path13) => only.includes(path13)) };
+  }
+  if (shard !== null) {
+    if (shard.total > gates.length) {
+      return {
+        error: `--shard ${shard.index}/${shard.total}: there are only ${gates.length} gate(s). A part without a gate would pass without checking anything`
+      };
+    }
+    return {
+      selected: gates.filter((_path, position) => position % shard.total === shard.index - 1)
+    };
+  }
+  return { selected: mode === "first" ? gates.slice(0, 1) : gates };
+}
+var VERIFIED_RUNS = [
+  { runner: "jest", versions: ["30.5"], provider: "babel", pools: ["default"] },
+  { runner: "vitest", versions: ["3.2"], provider: "istanbul", pools: ["forks", "threads"] }
+];
+function minorOf(version) {
+  const match = /^(\d+\.\d+)\./.exec(version);
+  return match === null ? version : match[1];
+}
+function unverifiedVersion(runner, version, table = VERIFIED_RUNS) {
+  const known = table.find((entry) => entry.runner === runner);
+  if (known === void 0) {
+    return `the shared run is not verified with ${runner}`;
+  }
+  return known.versions.includes(minorOf(version)) ? null : `the shared run is verified with ${runner} ${known.versions.join(", ")}, not with ${version}`;
+}
+var SURROUNDINGS = /\bprocess\s*\.\s*env\b|\bimport\.meta\.env\b|['"`](?:node:)?(?:fs|fs\/promises|child_process|worker_threads|net|http|https)['"`]/;
+function inCi(env) {
+  const ci = (env.CI ?? "").trim().toLowerCase();
+  return ci !== "" && ci !== "false" && ci !== "0";
+}
+function quickRefused(env) {
+  return inCi(env) ? "--quick is refused in CI (the variable CI is set): what it reports as holding is not the final check. Run selfcheck without it, with --shard to split it over jobs" : null;
+}
+function gateRunRefused(env) {
+  return inCi(env) ? "--gate is refused in CI (the variable CI is set): a mutation run of a part of the gates is not the final check. Run mutation without it" : null;
+}
+function affectedRefused(env) {
+  return inCi(env) ? "CI is set, and there every mutant is run (the final check)" : null;
+}
+function gateRunCaveat(judged, all) {
+  return `. Only ${judged} of ${all} gate(s) were run and judged (--gate), and a change in one gate can make a mutant of another survive: run without --gate for the final check`;
+}
+function quickCaveat(shared) {
+  return shared === 0 ? "" : `. Of the controls that held, ${shared} came from one shared run (--quick), which a spec that depends on other specs can make differ from a run per gate: run without --quick for the final check`;
+}
+function sharedRunPrecheck(input) {
+  const reaching = input.specs.find((spec) => SURROUNDINGS.test(spec.source));
+  if (reaching !== void 0) {
+    return `${reaching.path} reads the environment or files, so what it executes may depend on which other specs ran`;
+  }
+  const runner = ["jest", "vitest"].find((name) => name === input.program);
+  if (runner === void 0) {
+    return null;
+  }
+  if (input.version !== null) {
+    const unverified = unverifiedVersion(runner, input.version);
+    if (unverified !== null) {
+      return unverified;
+    }
+  }
+  if (input.configSource === null) {
+    return null;
+  }
+  const helper = runner === "jest" ? "createJestGatesConfig" : "createVitestGatesConfig";
+  if (!input.configSource.includes(helper)) {
+    return `the gate config does not use ${helper}`;
+  }
+  if (runner === "vitest" && !input.configSource.includes("istanbul")) {
+    return "Vitest measures with the v8 provider; the shared run needs coverageProvider: 'istanbul'";
+  }
+  return null;
+}
+function unverifiedRun(run) {
+  if (run.problem !== null) {
+    return run.problem;
+  }
+  const version = unverifiedVersion(run.runner, run.version);
+  if (version !== null) {
+    return version;
+  }
+  const known = VERIFIED_RUNS.find(
+    (entry) => entry.runner === run.runner
+  );
+  if (known.provider !== run.provider) {
+    return `the shared run is not verified with the coverage provider ${run.provider}`;
+  }
+  if (!known.pools.includes(run.pool)) {
+    return `the shared run is not verified with the pool ${run.pool}`;
+  }
+  if (!run.isolate) {
+    return "the shared run is not verified with spec files that share their modules (isolate: false)";
+  }
+  if (run.projects !== 1) {
+    return `the shared run is not verified with ${run.projects} projects in one run`;
+  }
+  return null;
+}
+function sorted(counts) {
+  return [...counts].sort((left, right) => left - right);
+}
+function same(left, right) {
+  return left.every((count, index) => count === right[index]);
+}
+function contained(part, whole) {
+  const left = sorted(whole);
+  return sorted(part).every((count) => {
+    const position = left.indexOf(count);
+    if (position === -1) {
+      return false;
+    }
+    left.splice(position, 1);
+    return true;
+  });
+}
+function accountedFor(total, parts) {
+  const first = parts[0];
+  if (total === void 0 || first === void 0) {
+    return "unknown";
+  }
+  const lined = parts.every(
+    (part) => part.s.length === first.s.length && part.f.length === first.f.length && part.b.length === first.b.length
+  );
+  if (!lined || total.f.length !== first.f.length || total.b.length !== first.b.length) {
+    return "unknown";
+  }
+  const sum = (key) => first[key].map(
+    (_count, index) => parts.reduce((added, part) => added + part[key][index], 0)
+  );
+  return same(sorted(total.f), sorted(sum("f"))) && same(sorted(total.b), sorted(sum("b"))) && contained(total.s, sum("s")) ? "yes" : "no";
+}
+function planControls(input) {
+  const { all, targets, run, notes, totals } = input;
+  const everyoneAlone = (reason) => ({ together: [], alone: targets, reason });
+  if (input.failurePattern && !input.failurePattern.includes("{gate}")) {
+    return everyoneAlone("settings.selfcheck.failurePattern does not contain {gate}");
+  }
+  if (run === null || notes === null || totals === null) {
+    return everyoneAlone(
+      "the gate run left no notes (the gate config does not use the helpers of this package, or Vitest measures with the v8 provider)"
+    );
+  }
+  const unverified = unverifiedRun(run);
+  if (unverified !== null) {
+    return everyoneAlone(unverified);
+  }
+  const silent = all.find((gate) => !notes.some((note) => note.spec === gate.specFile));
+  if (silent !== void 0) {
+    return everyoneAlone(`the gate run left no note for the spec of ${silent.path}`);
+  }
+  const partsOf = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
+  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf(gate)) === "no");
+  if (short !== void 0) {
+    return everyoneAlone(
+      `the notes of the specs do not add up to what the runner counted for ${short.path}`
+    );
+  }
+  const together = targets.filter((target) => {
+    const gate = all.find((candidate) => candidate.path === target);
+    if (gate === void 0) {
+      return false;
+    }
+    if (all.some((other) => other.path !== gate.path && other.path.includes(gate.path))) {
+      return false;
+    }
+    if (accountedFor(totals[gate.file], partsOf(gate)) !== "yes") {
+      return false;
+    }
+    const touching = notes.filter((note) => {
+      const counters = note.files[gate.file];
+      return counters !== void 0 && [...counters.s, ...counters.f, ...counters.b].some((count) => count !== 0);
+    }).map((note) => note.spec);
+    return touching.length === 1 && touching.includes(gate.specFile);
+  });
+  if (together.length < 2) {
+    return everyoneAlone("fewer than two gates are touched by their own spec only");
+  }
+  return { together, alone: targets.filter((target) => !together.includes(target)), reason: null };
+}
 
 // src/load.ts
 function readManifest(dir) {
@@ -970,9 +1236,12 @@ function readManifest(dir) {
     }
     throw error;
   }
+  const listing = /* @__PURE__ */ new Map();
   const gates = parsed.gates.map((gate) => {
     const specCandidates = specCandidatesFor(gate.path, settings);
-    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    const existingSpecs = specCandidates.filter(
+      (candidate) => existsExact(absoluteDir, candidate, "file", listing)
+    );
     return {
       ...gate,
       specCandidates,
@@ -1020,6 +1289,7 @@ function isPlainRelativePath(file) {
 function checkGates(manifest) {
   const { dir, settings } = manifest;
   const violations = [...manifest.violations];
+  const listing = /* @__PURE__ */ new Map();
   for (const gate of manifest.gates) {
     if (!isPlainRelativePath(gate.path)) {
       violations.push({
@@ -1047,7 +1317,7 @@ function checkGates(manifest) {
         });
       }
     }
-    if (!existsExact(dir, gate.path)) {
+    if (!existsExact(dir, gate.path, "file", listing)) {
       violations.push({
         file: gate.path,
         message: "file not found (the check is case-sensitive)"
@@ -1076,7 +1346,7 @@ function checkGates(manifest) {
     violations.push(...scanSpecSource(gate.path, specPath, readText(dir, specPath), settings));
   }
   for (const candidate of manifest.candidates) {
-    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any")) {
+    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any", listing)) {
       violations.push({
         file: MANIFEST_FILE,
         message: `${candidate.path}: candidate not found. Remove it, or fix the path`
@@ -1138,548 +1408,2621 @@ function runCheck(dir, io2) {
   return 0;
 }
 
-// src/commands/lcov.ts
-import fs4 from "fs";
-import path4 from "path";
+// src/commands/doctor.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import fs9 from "fs";
+import path9 from "path";
 
-// src/core/lcov.ts
-function normalizePath(file, rootDir) {
-  let normalized = file.replace(/\\/g, "/");
-  if (rootDir !== void 0) {
-    const root = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
-    if (normalized.startsWith(`${root}/`)) {
-      normalized = normalized.slice(root.length + 1);
+// src/core/reuse-guard.ts
+var RECORD_FORMAT = 2;
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+var isStringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+function parseAffected(value) {
+  const { tests, gates } = value ?? {};
+  if (!isStringList(tests) || typeof gates !== "object" || gates === null || Array.isArray(gates)) {
+    return null;
+  }
+  const parsed = /* @__PURE__ */ Object.create(null);
+  for (const [gate, entry] of Object.entries(gates)) {
+    const { specs, files } = entry ?? {};
+    if (!isStringList(specs) || !isStringList(files)) {
+      return null;
     }
+    parsed[gate] = { specs, files };
   }
-  return normalized.replace(/^\.\//, "");
+  return { tests, gates: parsed };
 }
-function parseLcov(text, rootDir) {
-  const files = /* @__PURE__ */ new Map();
-  let record = null;
-  const closeRecord = () => {
-    if (record && !record.hasDa) {
-      record.file.found += record.found;
-      record.file.hit += record.hit;
+function parseRecord(value) {
+  const { format, incremental, snapshot, affected } = value ?? {};
+  if (format !== RECORD_FORMAT || typeof incremental !== "string") {
+    return null;
+  }
+  if (typeof snapshot !== "object" || snapshot === null) {
+    return null;
+  }
+  const { mode, environment, args, files } = snapshot;
+  if (mode !== "git" && mode !== "walk") {
+    return null;
+  }
+  if (!isStringList(args) || !isStringRecord(environment) || !isStringRecord(files)) {
+    return null;
+  }
+  const record = { format, incremental, snapshot: { mode, environment, args, files } };
+  if (affected !== void 0) {
+    const parsed = parseAffected(affected);
+    if (parsed === null) {
+      return null;
     }
-    record = null;
+    record.affected = parsed;
+  }
+  return record;
+}
+function listed(names) {
+  const shown = names.slice(0, 3).join(", ");
+  return names.length > 3 ? `${shown} and ${names.length - 3} more` : shown;
+}
+function differingKeys(before, after) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((key) => before[key] !== after[key]).sort();
+}
+function readRecord(input) {
+  if (input.record === void 0) {
+    return { refused: "there is no record of the run that wrote the incremental file" };
+  }
+  const record = parseRecord(input.record);
+  if (record === null) {
+    return { refused: "the record of the last run is not one this version can read" };
+  }
+  if (record.incremental !== input.incremental) {
+    return { refused: "the incremental file is not the one the last recorded run wrote" };
+  }
+  const before = record.snapshot;
+  const now = input.snapshot;
+  if (before.mode !== now.mode) {
+    return {
+      refused: `the files are listed in another way than in the last run (${before.mode}, now ${now.mode})`
+    };
+  }
+  const environment = differingKeys(before.environment, now.environment);
+  if (environment.length > 0) {
+    const changes = environment.map(
+      (key) => `${key} ${before.environment[key] ?? "none"} \u2192 ${now.environment[key] ?? "none"}`
+    );
+    return { refused: `the tools changed since the last run: ${listed(changes)}` };
+  }
+  if (JSON.stringify(before.args) !== JSON.stringify(now.args)) {
+    return { refused: "the arguments for Stryker are not those of the last run" };
+  }
+  return { record };
+}
+function refuseReuse(input) {
+  const read2 = readRecord(input);
+  if ("refused" in read2) {
+    return read2.refused;
+  }
+  const files = differingKeys(read2.record.snapshot.files, input.snapshot.files);
+  if (files.length > 0) {
+    return `changed since the last run: ${listed(files)}`;
+  }
+  return null;
+}
+function incrementalOptions(config, args) {
+  const options = typeof config === "object" && config !== null ? config : {};
+  const valueOf = (name) => {
+    let value;
+    args.forEach((arg, position) => {
+      if (arg === name) {
+        value = args[position + 1];
+      } else if (arg.startsWith(`${name}=`)) {
+        value = arg.slice(name.length + 1);
+      }
+    });
+    return value;
   };
-  for (const rawLine of text.split("\n")) {
-    const line = rawLine.trim();
-    if (line.startsWith("SF:")) {
-      closeRecord();
-      const path7 = normalizePath(line.slice(3), rootDir);
-      const file = files.get(path7) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
-      files.set(path7, file);
-      record = { file, hasDa: false, found: 0, hit: 0 };
-    } else if (line === "end_of_record") {
-      closeRecord();
-    } else if (record) {
-      const open = record;
-      if (line.startsWith("DA:")) {
-        const [lineNumber, hits] = line.slice(3).split(",");
-        const number = Number(lineNumber);
-        const count = Number(hits);
-        if (Number.isInteger(number) && Number.isFinite(count)) {
-          open.hasDa = true;
-          open.file.lines.set(number, Math.max(open.file.lines.get(number) ?? 0, count));
-        }
-      } else if (line.startsWith("LF:")) {
-        open.found = Number(line.slice(3)) || 0;
-      } else if (line.startsWith("LH:")) {
-        open.hit = Number(line.slice(3)) || 0;
+  const fromConfig = (name, fallback) => typeof options[name] === "string" ? options[name] : fallback;
+  return {
+    incremental: options.incremental === true || args.includes("--incremental"),
+    force: options.force === true || args.includes("--force"),
+    incrementalFile: valueOf("--incrementalFile") ?? fromConfig("incrementalFile", "reports/stryker-incremental.json"),
+    tempDirName: valueOf("--tempDirName") ?? fromConfig("tempDirName", ".stryker-tmp")
+  };
+}
+function comparableArgs(args) {
+  return args.filter((arg) => arg !== "--force");
+}
+
+// src/core/affected.ts
+var CONFIG_NAMES = [
+  /^package\.json$/,
+  /^(?:package-lock|npm-shrinkwrap)\.json$/,
+  /^test-gates\.json$/,
+  /^[jt]sconfig(?:\..*)?\.json$/,
+  /\.config\.[^.]+$/,
+  /\.config\.[^.]+\.[^.]+$/,
+  /^(?:jest|vitest|vite|stryker|babel)[.-]/,
+  /^\./,
+  // Declarations need no import to take effect.
+  /\.d\.[cm]?ts$/
+];
+var CONFIG_DIRECTORIES = ["__mocks__", "node_modules"];
+var DOCUMENT = /\.(?:md|markdown|txt|rst|adoc)$/i;
+var PASSIVE = /\.(?:[cm]?[jt]sx?|json|snap|css|scss|sass|less|svg|png|jpe?g|gif|webp|avif|ico)$/i;
+function kindOf(key, subproject) {
+  const inside = subproject === "" || key.startsWith(`${subproject}/`);
+  const local = inside && subproject !== "" ? key.slice(subproject.length + 1) : key;
+  const segments = local.split("/");
+  const name = segments[segments.length - 1];
+  if (segments.some((segment) => CONFIG_DIRECTORIES.includes(segment)) || CONFIG_NAMES.some((pattern) => pattern.test(name))) {
+    return "config";
+  }
+  if (DOCUMENT.test(name)) {
+    return "document";
+  }
+  if (!inside || segments.length === 1 || !PASSIVE.test(name)) {
+    return "other";
+  }
+  return "passive";
+}
+function gateDependencies(input) {
+  const closureOf = (key) => Object.hasOwn(input.closures, key) ? input.closures[key] : [key];
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const gate of input.gates) {
+    const covering = Object.hasOwn(input.covering, gate.key) ? input.covering[gate.key] : [];
+    const specs = /* @__PURE__ */ new Set([...gate.specs, ...covering]);
+    for (const test of input.tests) {
+      if (closureOf(test).includes(gate.key)) {
+        specs.add(test);
       }
     }
-  }
-  closeRecord();
-  const result = /* @__PURE__ */ new Map();
-  for (const [file, accumulator] of files) {
-    const uncovered = [...accumulator.lines.entries()].filter(([, hits]) => hits <= 0).map(([lineNumber]) => lineNumber).sort((a, b) => a - b);
-    result.set(file, {
-      found: accumulator.lines.size + accumulator.found,
-      hit: accumulator.lines.size - uncovered.length + accumulator.hit,
-      uncovered
-    });
+    const files = new Set(closureOf(gate.key));
+    for (const spec of specs) {
+      closureOf(spec).forEach((file) => files.add(file));
+    }
+    result[gate.key] = { specs: [...specs].sort(), files: [...files].sort() };
   }
   return result;
 }
-function judgeLcov(gatePaths, coverage) {
-  const violations = [];
-  const results = [];
-  for (const gatePath of gatePaths) {
-    const file = coverage.get(normalizePath(gatePath));
-    if (!file) {
-      violations.push({ file: gatePath, message: "no record in the lcov file" });
-      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
-      continue;
-    }
-    if (file.found === 0) {
-      violations.push({ file: gatePath, message: "no instrumented lines in the lcov record" });
-      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+function planAffected(input) {
+  const recorded = input.before.affected;
+  if (recorded === void 0) {
+    return {
+      full: "the last run did not write down what each gate depends on (it ran without --affected)"
+    };
+  }
+  const changed = differingKeys(input.before.files, input.now);
+  const reached = new Set(input.gates.flatMap((gate) => gate.files));
+  Object.values(recorded.gates).forEach((gate) => gate.files.forEach((file) => reached.add(file)));
+  const config = new Set(input.config);
+  const everywhere = changed.filter((key) => {
+    const kind = kindOf(key, input.subproject);
+    return config.has(key) || kind === "config" || kind === "other" && !reached.has(key);
+  });
+  if (everywhere.length > 0) {
+    return { full: `changed since the last run, and may affect every gate: ${listed(everywhere)}` };
+  }
+  const rerun = [];
+  const reused = [];
+  for (const gate of input.gates) {
+    const last = Object.hasOwn(recorded.gates, gate.path) ? recorded.gates[gate.path] : void 0;
+    if (last === void 0) {
+      rerun.push({ gate: gate.path, changed: [] });
       continue;
     }
-    const ok = file.hit === file.found;
-    if (!ok) {
-      const shown = file.uncovered.slice(0, 20).join(", ");
-      const more = file.uncovered.length > 20 ? ", \u2026" : "";
-      violations.push({
-        file: gatePath,
-        ...file.uncovered[0] === void 0 ? {} : { line: file.uncovered[0] },
-        message: `${file.hit}/${file.found} lines covered` + (shown === "" ? "" : ` (uncovered: ${shown}${more})`)
-      });
+    const files = [.../* @__PURE__ */ new Set([...last.files, ...gate.files])];
+    const differing = files.filter((file) => input.before.files[file] !== input.now[file]).sort();
+    if (differing.length > 0) {
+      rerun.push({ gate: gate.path, changed: differing });
+    } else {
+      reused.push(gate.path);
     }
-    results.push({ path: gatePath, found: file.found, hit: file.hit, ok });
   }
-  return { violations, results };
+  return { rerun, reused };
 }
-function summarizeLcov(coverage, exclude) {
-  let found = 0;
-  let hit = 0;
-  for (const [file, lines] of coverage) {
-    if (exclude.some((regex) => regex.test(file))) {
+function withoutDots(file) {
+  return file.split("/").filter((part) => part !== ".").join("/");
+}
+function timeoutRanges(last, gates) {
+  const ranges = [];
+  const files = last.files ?? {};
+  for (const named of gates) {
+    const gate = withoutDots(named);
+    const mutants = Object.hasOwn(files, gate) ? files[gate]?.mutants : void 0;
+    if (mutants === void 0) {
       continue;
     }
-    found += lines.found;
-    hit += lines.hit;
+    for (const mutant of mutants) {
+      if (mutant.status === "Timeout") {
+        const { start, end } = mutant.location;
+        ranges.push(`${gate}:${start.line}:${start.column - 1}-${end.line}:${end.column}`);
+      }
+    }
   }
-  return { found, hit };
+  return [...new Set(ranges)];
 }
-
-// src/commands/lcov.ts
-function runLcov(dir, fileOption, io2) {
-  const manifest = readManifest(dir);
-  const file = fileOption ?? manifest.settings.lcovFile;
-  if (file === null) {
-    throw new ManifestError(
-      "no lcov file given. Pass --file <lcov.info> or set settings.lcov.file"
-    );
+function describePlan(plan, shown = 5, timeouts = 0) {
+  if ("full" in plan) {
+    return [
+      `test-gates mutation --affected: running every mutant again (--force), the results of the last run are not reused: ${plan.full}`
+    ];
   }
-  const lcovPath = path4.resolve(manifest.dir, file);
-  let text;
-  try {
-    text = fs4.readFileSync(lcovPath, "utf8");
-  } catch (error) {
-    io2.err(
-      `test-gates lcov: cannot read ${file} (${error.message}). Run the tests with coverage first`
+  const total = plan.rerun.length + plan.reused.length;
+  const lines = [
+    `test-gates mutation --affected: ${plan.reused.length} of ${total} gate(s) reused, ${plan.rerun.length} run again`
+  ];
+  for (const { gate, changed } of plan.rerun.slice(0, shown)) {
+    lines.push(
+      changed.length === 0 ? `  ${gate}: the last run left no result of it that can be reused` : `  ${gate}: changed ${listed(changed)}`
     );
-    return 1;
   }
-  const violations = [...manifest.violations];
-  const existing = manifest.gates.filter((gate) => {
-    const exists = existsExact(manifest.dir, gate.path);
-    if (!exists) {
-      violations.push({
-        file: gate.path,
-        message: "file not found (the check is case-sensitive). Update test-gates.json if it moved"
-      });
-    }
-    return exists;
-  });
-  const coverage = parseLcov(text, manifest.dir);
-  const total = summarizeLcov(coverage, manifest.settings.lcovSummaryExclude);
-  io2.out(
-    total.found === 0 ? "reference: no instrumented lines in the lcov file" : `reference: overall line coverage ${(total.hit / total.found * 100).toFixed(2)}% (${total.hit}/${total.found}, not gated)`
-  );
-  const verdict = judgeLcov(
-    existing.map((gate) => gate.path),
-    coverage
-  );
-  for (const result of verdict.results) {
-    if (result.ok) {
-      io2.out(`  \u2713 ${result.path}: ${result.hit}/${result.found} lines`);
-    }
+  if (plan.rerun.length > shown) {
+    lines.push(`  and ${plan.rerun.length - shown} more`);
   }
-  violations.push(...verdict.violations);
-  if (violations.length > 0) {
-    printViolations(io2, "lcov", violations);
-    return 1;
+  if (timeouts > 0) {
+    lines.push(`  and ${timeouts} mutant(s) of reused gates that timed out in the last run`);
   }
-  io2.out(`test-gates lcov: OK (${verdict.results.length} gate(s) at 100% line coverage)`);
-  return 0;
+  return lines;
 }
 
-// src/commands/mutation.ts
-import { spawnSync } from "child_process";
-import fs6 from "fs";
+// src/core/doctor.ts
+var NOT_THE_HELPER = "the runner config is not made with";
+function diagnose(facts) {
+  const findings = [];
+  if (!facts.incremental) {
+    findings.push({
+      level: "problem",
+      text: "Stryker does not run in incremental mode: every run is one of every mutant",
+      fix: "make the Stryker config with createStrykerGatesConfig, or set incremental: true"
+    });
+    return findings;
+  }
+  if (facts.forced) {
+    findings.push({
+      level: "problem",
+      text: "the Stryker config sets force: every run is one of every mutant",
+      fix: "remove force from the Stryker config; pass -- --force where a full run is meant (CI)"
+    });
+  }
+  if (facts.failure !== null) {
+    findings.push({
+      level: "problem",
+      text: `the results of a run are never reused: ${facts.failure}`,
+      fix: facts.failure.includes("points outside") ? "remove the path, or let it lead into the repository. A path that leads outside of it to nothing is compared as missing" : null
+    });
+  }
+  if (facts.widened.length > 0) {
+    findings.push({
+      level: "problem",
+      text: `every file of the repository is compared, so a change anywhere in it makes the next run a full one. Because of: ${facts.widened.join("; ")}`,
+      fix: "write such a path from the directory of its file (path.resolve(__dirname, \u2026)) so that it can be followed, or keep it out of the files the run loads"
+    });
+  }
+  if (facts.scope !== null && "every" in facts.scope) {
+    findings.push({
+      level: "note",
+      text: `the paths in every file of the subproject are followed, also in files the run does not load: ${facts.scope.every}`,
+      fix: facts.scope.every.startsWith(NOT_THE_HELPER) ? "make the runner config with createJestGatesConfig or createVitestGatesConfig" : null
+    });
+  }
+  if (facts.hooks.length === 0) {
+    findings.push({
+      level: "note",
+      text: "no git hook runs test-gates mutation for this subproject",
+      fix: null
+    });
+  }
+  for (const hook of facts.hooks.filter((one) => !one.affected)) {
+    findings.push({
+      level: "problem",
+      text: `${hook.file} runs test-gates mutation without --affected: a change of any file of the subproject runs every mutant`,
+      fix: "pass --affected in the hook (npm run test:gates:mutation -- --affected); keep the run in CI without it"
+    });
+  }
+  return findings;
+}
+function formatFindings(findings) {
+  const lines = [];
+  for (const finding of findings) {
+    lines.push(`${finding.level === "problem" ? "problem" : "note"}: ${finding.text}`);
+    if (finding.fix !== null) {
+      lines.push(`  fix: ${finding.fix}`);
+    }
+  }
+  const problems = findings.filter((finding) => finding.level === "problem").length;
+  lines.push(
+    problems === 0 ? "test-gates doctor: OK" : `test-gates doctor: ${problems} problem(s) that make runs full ones`
+  );
+  return { lines, status: problems === 0 ? 0 : 1 };
+}
+var RUNS_MUTATION = /(?<![\w-])test-gates(?:\.js)?\s+mutation(?![\w-])|(?<![\w:-])test:gates:mutation(?![\w:-])/;
+var TARGET = /(?:--dir|--prefix|--workspace|-w)(?:=|\s+)(['"]?)([^\s'";&|)]+)\1/;
+var CD = /\bcd\s+(['"]?)([^\s'";&|)]+)\1/;
+function hookUses(input) {
+  const lines = input.text.split("\n").map((line) => line.replace(/(?:^|\s)#.*/, ""));
+  const uses = [];
+  lines.forEach((line, index) => {
+    if (!RUNS_MUTATION.test(line)) {
+      return;
+    }
+    const named = TARGET.exec(line) ?? CD.exec(line);
+    const target = named?.[2] ?? lines.slice(0, index).reverse().map((before) => CD.exec(before)?.[2]).find((found) => found !== void 0);
+    const normalized = target?.split("/").filter((part) => part !== "." && part !== "").join("/");
+    const ours = normalized === void 0 || normalized.includes("$") || normalized.includes("..") || normalized === input.subproject;
+    if (ours) {
+      uses.push({
+        file: input.file,
+        affected: /--affected\b/.test(line) || /test:gates:mutation\b/.test(line) && input.script.includes("--affected")
+      });
+    }
+  });
+  return uses;
+}
 
-// src/commands/mutation-result.ts
+// src/snapshot.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
 import fs5 from "fs";
+import { createRequire } from "module";
+import os from "os";
 import path5 from "path";
 
-// src/core/mutation-result.ts
-var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
-var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
-var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
-function normalizeCode(text) {
-  return text.replace(/\s+/g, " ").trim();
+// src/commands/loaded-files.ts
+import fs4 from "fs";
+import { builtinModules } from "module";
+import path4 from "path";
+var SCRIPT = /\.[cm]?[jt]sx?$/;
+var COMPONENT = /\.(?:vue|svelte|astro|mdx)$/;
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var QUOTED = /(['"`])([^'"`\n]+)\1/g;
+var RUNNER_LOAD = /\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule)\(\s*(['"`])([^'"`\n]+)\1/g;
+function isFile(file) {
+  try {
+    return fs4.statSync(file).isFile();
+  } catch {
+    return false;
+  }
 }
-function normalizePath2(file) {
-  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+function resolveFile(base, directory = true) {
+  const candidates = [
+    base,
+    ...EXTENSIONS.map((extension) => base + extension),
+    // `./fee.js` written in a TypeScript file is `./fee.ts`
+    ...EXTENSIONS.map((extension) => base.replace(/\.[cm]?jsx?$/, extension)),
+    ...directory ? EXTENSIONS.map((extension) => path4.join(base, `index${extension}`)) : []
+  ];
+  return candidates.find(isFile) ?? null;
 }
-function normalizeNewlines(text) {
-  return text.replace(/\r\n/g, "\n");
+function installed(specifier, from) {
+  const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+  for (let current = path4.dirname(from); ; current = path4.dirname(current)) {
+    if (fs4.existsSync(path4.join(current, "node_modules", name))) {
+      return true;
+    }
+    if (current === path4.dirname(current)) {
+      return false;
+    }
+  }
 }
-function sliceByLocation(source, location) {
-  const lines = source.split("\n");
-  const { start, end } = location;
-  const first = lines[start.line - 1];
-  const last = lines[end.line - 1];
-  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+function loadedFiles(manifest, configFile) {
+  const aliases = manifest.settings.importAliases;
+  const relative = (file) => path4.relative(manifest.dir, file).split(path4.sep).join("/");
+  const target = (specifier, from) => {
+    if (specifier.startsWith(".")) {
+      return resolveFile(path4.resolve(path4.dirname(from), specifier));
+    }
+    const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
+    return alias === void 0 ? null : resolveFile(
+      path4.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
+    );
+  };
+  const read2 = (file) => {
+    const source = fs4.readFileSync(file, "utf8");
+    const imports = parseImports(source).filter((ref) => !ref.typeOnly);
+    const specifiers = [
+      .../* @__PURE__ */ new Set([
+        ...imports.map((ref) => ref.module),
+        ...[...source.matchAll(RUNNER_LOAD)].map((match) => match[2])
+      ])
+    ];
+    const strings = [...source.matchAll(QUOTED)].map((match) => match[2]).filter((text) => !specifiers.includes(text));
+    return { source, specifiers, strings };
+  };
+  const named = /* @__PURE__ */ new Set();
+  const configs = configFile === null ? [] : [path4.resolve(manifest.dir, configFile)];
+  const seenConfigs = new Set(configs);
+  const entry = configs[0];
+  for (let file = configs.shift(); file !== void 0; file = configs.shift()) {
+    const { specifiers, strings } = read2(file);
+    const paths = strings.filter((text) => file === entry || /^(?:\.|<rootDir>\/)/.test(text));
+    for (const text of paths) {
+      const stripped = text.replace(/^<rootDir>\//, "");
+      const found = resolveFile(path4.resolve(path4.dirname(file), stripped), false) ?? resolveFile(path4.resolve(manifest.dir, stripped), false);
+      if (found !== null && SCRIPT.test(found)) {
+        named.add(found);
+      }
+    }
+    for (const specifier of specifiers.filter((one) => isProjectImport(one, aliases))) {
+      const found = target(specifier, file);
+      if (found !== null && SCRIPT.test(found) && !seenConfigs.has(found)) {
+        seenConfigs.add(found);
+        configs.push(found);
+      }
+    }
+  }
+  const known = /* @__PURE__ */ new Map();
+  const visit = (file) => {
+    const done = known.get(file);
+    if (done !== void 0) {
+      return done;
+    }
+    const { source, specifiers, strings } = read2(file);
+    const imports = [];
+    const next = [];
+    let lost = COMPONENT.test(file) ? `${relative(file)} is a component, which can use others that it does not import` : null;
+    for (const specifier of specifiers) {
+      if (isProjectImport(specifier, aliases)) {
+        const found = target(specifier, file);
+        if (found === null) {
+          lost ??= `${specifier} (imported by ${relative(file)})`;
+        } else {
+          next.push(found);
+        }
+      } else if (specifier.startsWith("node:") || builtinModules.includes(specifier)) {
+        imports.push({ specifier, builtin: true });
+      } else if (installed(specifier, file)) {
+        imports.push({ specifier, builtin: false });
+      } else {
+        lost ??= `${specifier} (imported by ${relative(file)})`;
+      }
+    }
+    for (const text of strings.filter((one) => one.startsWith("."))) {
+      const found = resolveFile(path4.resolve(path4.dirname(file), text));
+      if (found !== null) {
+        next.push(found);
+      }
+    }
+    const visited = {
+      file: { path: relative(file), source, imports },
+      // A component imports like a script (see COMPONENT); data imports nothing.
+      next: next.filter((found) => SCRIPT.test(found) || COMPONENT.test(found)),
+      lost
+    };
+    known.set(file, visited);
+    return visited;
+  };
+  const closure = (spec, starts) => {
+    const queue = [...starts];
+    const seen = new Set(queue);
+    const files = [];
+    let lost = null;
+    for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+      const visited = visit(file);
+      files.push(visited.file.path);
+      lost ??= visited.lost;
+      for (const found of visited.next.filter((one) => !seen.has(one))) {
+        seen.add(found);
+        queue.push(found);
+      }
+    }
+    return { spec, files, lost };
+  };
+  const specs = [...new Set(manifest.gates.flatMap((gate) => gate.existingSpecs))];
+  const roots = [
+    closure(null, [...named]),
+    ...specs.map((spec) => closure(spec, [path4.join(manifest.dir, spec)]))
+  ];
+  return { files: [...known.values()].map((visited) => visited.file), roots };
+}
+
+// src/snapshot.ts
+var SnapshotError = class extends Error {
+};
+var TOOLS = [
+  "@stryker-mutator/core",
+  "@stryker-mutator/jest-runner",
+  "@stryker-mutator/vitest-runner",
+  "@stryker-mutator/typescript-checker",
+  "jest",
+  "babel-jest",
+  "ts-jest",
+  "@swc/jest",
+  "vitest",
+  "vite",
+  "@vitest/coverage-istanbul",
+  "@vitest/coverage-v8",
+  "typescript"
+];
+var INSTALL_MARKERS = [
+  ".package-lock.json",
+  ".yarn-integrity",
+  ".yarn-state.yml",
+  ".modules.yaml"
+];
+var LOCK_FILES = [
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lock",
+  "bun.lockb"
+];
+var NEVER = ["node_modules", ".git"];
+var WIDENED_SHOWN = 5;
+var SCAN_LIMIT = 8 * 1024 * 1024;
+var UPWARD = /(['"`])((?:[^'"`\n]*\/)?\.\.(?:\/[^'"`\n]*)?)\1/g;
+var DOCUMENTS = [".md", ".markdown", ".txt", ".rst", ".adoc"];
+var HERE = /^\$\{(?:__dirname|import\.meta\.dirname)\}(?=\/)/;
+var FROM_HERE = /\b(?:__dirname|import\.meta\.dirname)((?:\s*,\s*(['"])[^'"`\n]*\2)+)(\s*\))?/g;
+var LITERAL = /(['"])([^'"`\n]*)\1/g;
+var isUpward = (segment) => segment.split("/").includes("..");
+function hashOf(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashFile(file) {
+  try {
+    return hashOf(fs5.readFileSync(file));
+  } catch {
     return null;
   }
-  if (start.line === end.line) {
-    return first.slice(start.column - 1, end.column - 1);
+}
+function isInside(parent, child) {
+  const relative = path5.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function toPosix(file) {
+  return file.split(path5.sep).join("/");
+}
+function gitEnvironment(env) {
+  if (env.GIT_DIR === void 0 || env.GIT_WORK_TREE !== void 0) {
+    return env;
   }
-  return [
-    first.slice(start.column - 1),
-    ...lines.slice(start.line, end.line - 1),
-    last.slice(0, end.column - 1)
-  ].join("\n");
+  const rest = { ...env };
+  delete rest.GIT_DIR;
+  return rest;
 }
-function keyOf(mutator, original, replacement) {
-  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+function git(cwd, args) {
+  const result = spawnSync("git", args, {
+    cwd,
+    env: gitEnvironment(process.env),
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 1024
+  });
+  return result.error || result.status !== 0 ? null : result.stdout;
 }
-function describeMutant(file, entry) {
-  const { mutant } = entry;
-  return {
-    file,
-    line: mutant.location.start.line,
-    column: mutant.location.start.column,
-    status: mutant.status,
-    mutator: mutant.mutatorName,
-    original: normalizeCode(entry.original),
-    replacement: normalizeCode(entry.replacement),
-    occurrence: entry.occurrence,
-    sameKeyCount: entry.sameKeyCount,
-    allowance: {
-      mutator: mutant.mutatorName,
-      original: normalizeCode(entry.original),
-      replacement: normalizeCode(entry.replacement),
-      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
-      reason: ""
+function gitLister(root) {
+  return (directory, recursive) => {
+    const relative = toPosix(path5.relative(root, directory));
+    const pattern = recursive ? `${relative === "" ? "" : `${relative}/`}**` : `${relative === "" ? "" : `${relative}/`}*`;
+    const listed2 = git(root, [
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      `:(glob)${pattern}`
+    ]);
+    if (listed2 === null) {
+      throw new SnapshotError("git could not list the files");
     }
+    return listed2.split("\0").filter((file) => file !== "");
   };
 }
-function describeAllowance(entry) {
-  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
-  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
-}
-function judgeMutationReport(input) {
-  const violations = [];
-  const survivors = [];
-  const unexpectedTimeouts = [];
-  const summary = {
-    total: 0,
-    detected: 0,
-    timeout: 0,
-    allowed: 0,
-    notEvaluable: 0,
-    unallowed: 0,
-    expectedTimeout: 0
+function walkLister(root) {
+  const walk = (directory, recursive, found) => {
+    for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
+      const file = path5.join(directory, entry.name);
+      if (NEVER.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (recursive) {
+          walk(file, true, found);
+        }
+      } else {
+        found.push(toPosix(path5.relative(root, file)));
+      }
+    }
+    return found;
   };
-  const files = /* @__PURE__ */ new Map();
-  for (const [file, result] of Object.entries(input.report.files ?? {})) {
-    files.set(normalizePath2(file), result);
+  return (directory, recursive) => walk(directory, recursive, []);
+}
+function upTo(from, to) {
+  const directories = [from];
+  while (directories[directories.length - 1] !== to) {
+    directories.push(path5.dirname(directories[directories.length - 1]));
   }
-  for (const gate of input.gates) {
-    const gatePath = normalizePath2(gate.path);
-    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
-    violations.push(...shapeViolations);
-    violations.push(
-      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
-    );
-    const result = files.get(gatePath);
-    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
-      violations.push({
-        file: gate.path,
-        message: "no mutants in the report (the gate was not mutation tested)"
-      });
-      continue;
-    }
-    const diskSource = input.readSource(gate.path);
-    const source = result.source ?? diskSource;
-    if (source === void 0) {
-      violations.push({
-        file: gate.path,
-        message: "source is neither in the report nor readable on disk"
-      });
-      continue;
-    }
-    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
-      violations.push({
-        file: gate.path,
-        message: "the report was made from a different version of this file. Run Stryker again"
-      });
-      continue;
+  return directories;
+}
+function declaresWorkspaces(directory) {
+  if (fs5.existsSync(path5.join(directory, "pnpm-workspace.yaml"))) {
+    return true;
+  }
+  try {
+    const manifest = JSON.parse(fs5.readFileSync(path5.join(directory, "package.json"), "utf8"));
+    return manifest.workspaces !== void 0;
+  } catch {
+    return false;
+  }
+}
+function walkRoot(dir) {
+  const candidates = withinBounds(dir);
+  const repository = candidates.find((directory) => fs5.existsSync(path5.join(directory, ".git")));
+  if (repository !== void 0) {
+    return repository;
+  }
+  return candidates.filter(declaresWorkspaces).pop() ?? dir;
+}
+function withinBounds(dir) {
+  let home = null;
+  try {
+    home = fs5.realpathSync(os.homedir());
+  } catch {
+  }
+  return upTo(dir, path5.parse(dir).root).filter(
+    (directory) => directory !== path5.parse(dir).root && (home === null || !isInside(directory, home))
+  );
+}
+function linkedPackages(nodeModules, root) {
+  const found = [];
+  const visit = (directory, depth) => {
+    let entries;
+    try {
+      entries = fs5.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
     }
-    const located = [];
-    const byKey = /* @__PURE__ */ new Map();
-    const sorted = [...result.mutants].sort(
-      (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
-    );
-    let locationsValid = true;
-    for (const mutant of sorted) {
-      const original = sliceByLocation(normalizeNewlines(source), mutant.location);
-      if (original === null) {
-        violations.push({
-          file: gate.path,
-          line: mutant.location.start.line,
-          message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
-        });
-        locationsValid = false;
-        continue;
+    for (const entry of entries) {
+      const file = path5.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        let target;
+        try {
+          target = fs5.realpathSync(file);
+        } catch {
+          continue;
+        }
+        if (target.split(path5.sep).includes("node_modules") || !fs5.statSync(target).isDirectory()) {
+          continue;
+        }
+        if (!isInside(root, target)) {
+          throw new SnapshotError(
+            `${file} is a link to a directory outside of what can be listed (${target})`
+          );
+        }
+        found.push(target);
+      } else if (depth === 0 && entry.isDirectory() && entry.name.startsWith("@")) {
+        visit(file, 1);
       }
-      const replacement = mutant.replacement ?? "";
-      const key = keyOf(mutant.mutatorName, original, replacement);
-      const group = byKey.get(key) ?? [];
-      const entry = {
-        mutant,
-        original,
-        replacement,
-        occurrence: group.length + 1,
-        sameKeyCount: 0
-      };
-      group.push(entry);
-      byKey.set(key, group);
-      located.push(entry);
     }
-    for (const group of byKey.values()) {
-      for (const entry of group) {
-        entry.sameKeyCount = group.length;
+  };
+  visit(nodeModules, 0);
+  return found;
+}
+function installedVersion(start, name) {
+  let current = start;
+  for (; ; ) {
+    try {
+      const manifest = JSON.parse(
+        fs5.readFileSync(path5.join(current, "node_modules", name, "package.json"), "utf8")
+      );
+      return typeof manifest.version === "string" ? manifest.version : "unknown";
+    } catch {
+      const parent = path5.dirname(current);
+      if (parent === current) {
+        return null;
       }
+      current = parent;
     }
-    if (!locationsValid) {
-      continue;
+  }
+}
+function ownVersion() {
+  const { version } = createRequire(import.meta.url)("../package.json");
+  return version;
+}
+function snapshotOf(input) {
+  const dir = fs5.realpathSync(input.dir);
+  const top = git(dir, ["rev-parse", "--show-toplevel"]);
+  let root = top === null ? dir : fs5.realpathSync(top.trim());
+  let lister = gitLister(root);
+  let mode = "git";
+  const manifest = toPosix(path5.relative(root, path5.join(dir, "test-gates.json")));
+  if (top === null || !lister(dir, false).includes(manifest)) {
+    mode = "walk";
+    root = walkRoot(dir);
+    lister = walkLister(root);
+  }
+  const listRoot = root;
+  const list = lister;
+  const followed = input.scope === void 0 ? null : input.scope(list(dir, true).map((file) => path5.join(listRoot, file)));
+  const walk = walkLister(listRoot);
+  const written = input.written.map((file) => {
+    const target = path5.resolve(dir, file);
+    try {
+      return fs5.realpathSync(target);
+    } catch {
+      return target;
     }
-    const claim = (field, entries, noun, accept) => {
-      const claimed = /* @__PURE__ */ new Set();
-      if (!Array.isArray(entries)) {
-        return claimed;
+  });
+  const swallowing = written.find((target) => isInside(target, path5.join(dir, "test-gates.json")));
+  if (swallowing !== void 0) {
+    throw new SnapshotError(`the run writes to ${swallowing}, which holds test-gates.json`);
+  }
+  const files = /* @__PURE__ */ Object.create(null);
+  const regions = [dir];
+  const widened = [];
+  const queued = new Set(regions);
+  const enqueue = (target, from, reference, anchored = false) => {
+    const above2 = target !== dir && isInside(target, dir) && isInside(listRoot, target);
+    if (above2 && anchored) {
+      return;
+    }
+    const directory = above2 ? listRoot : target;
+    if (!isInside(listRoot, directory)) {
+      const written2 = reference === void 0 ? "" : ` with ${JSON.stringify(reference)}`;
+      throw new SnapshotError(
+        `${toPosix(path5.relative(dir, from))} points outside of what can be listed${written2} (${directory})`
+      );
+    }
+    if (directory === listRoot && listRoot !== dir && widened.length < WIDENED_SHOWN) {
+      const written2 = reference === void 0 ? "" : ` ${JSON.stringify(reference)}`;
+      widened.push(`${toPosix(path5.relative(listRoot, from))}${written2}`);
+    }
+    if (![...queued].some((region) => isInside(region, directory))) {
+      queued.add(directory);
+      regions.push(directory);
+    }
+  };
+  const follow = (fixed, open, anchored, file, reference) => {
+    const target = path5.resolve(path5.dirname(file), fixed);
+    let isDirectory = false;
+    try {
+      isDirectory = fs5.statSync(target).isDirectory();
+    } catch {
+    }
+    if (!isDirectory && !isInside(listRoot, target) && resolveFile(target) === null) {
+      files[toPosix(path5.relative(listRoot, target))] = "missing";
+      return;
+    }
+    const directory = isDirectory ? target : path5.dirname(target);
+    if (fs5.existsSync(directory)) {
+      enqueue(directory, file, reference, anchored && !open);
+    }
+  };
+  const scan = (text, file) => {
+    const taken = [];
+    for (const match of text.matchAll(FROM_HERE)) {
+      const literals = match[1];
+      const segments = [...literals.matchAll(LITERAL)].map((literal) => literal[2]);
+      if (!segments.some(isUpward)) {
+        continue;
       }
-      entries.forEach((entry, index) => {
-        if (!isUsableEquivalentMutant(entry)) {
-          return;
-        }
-        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
-        const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
-        if (entry.occurrence === void 0 && group.length > 1) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
-          });
-          return;
+      const start = (match.index ?? 0) + match[0].indexOf(literals);
+      taken.push([start, start + literals.length]);
+      const end = (match.index ?? 0) + match[0].length;
+      const open = match[3] === void 0 || /^\s*[,+.}[]/.test(text.slice(end, end + 200));
+      const reference = match[0].slice(0, match[0].length - (match[3]?.length ?? 0));
+      follow(path5.posix.join(...segments), open, true, file, reference);
+    }
+    for (const match of text.matchAll(UPWARD)) {
+      const at = match.index ?? 0;
+      if (taken.some(([start, end]) => at >= start && at < end)) {
+        continue;
+      }
+      const literal = match[2];
+      const here = HERE.exec(literal);
+      const relative = here === null ? literal : `.${literal.slice(here[0].length)}`;
+      const open = relative.includes("${");
+      const fixed = open ? relative.slice(0, relative.lastIndexOf("/", relative.indexOf("${")) + 1) : relative;
+      if (here === null && !fixed.startsWith("../") || open && isUpward(relative.slice(relative.indexOf("${")))) {
+        enqueue(listRoot, file, literal);
+      } else {
+        follow(fixed, open, here !== null, file, literal);
+      }
+    }
+  };
+  const add = (relative) => {
+    const file = path5.join(listRoot, relative);
+    if (relative in files || written.some((target) => isInside(target, file))) {
+      return;
+    }
+    let stat;
+    try {
+      stat = fs5.lstatSync(file);
+    } catch {
+      files[relative] = "missing";
+      return;
+    }
+    if (stat.isSymbolicLink()) {
+      files[relative] = `link ${fs5.readlinkSync(file)}`;
+      let target;
+      try {
+        target = fs5.realpathSync(file);
+      } catch {
+        return;
+      }
+      enqueue(fs5.statSync(target).isDirectory() ? target : path5.dirname(target), file);
+    } else if (stat.isDirectory()) {
+      files[relative] = "directory";
+      walk(file, true).forEach(add);
+    } else if (!stat.isFile()) {
+      files[relative] = "special";
+    } else {
+      const content = fs5.readFileSync(file);
+      files[relative] = hashOf(content);
+      const document = DOCUMENTS.includes(path5.extname(file).toLowerCase());
+      const loaded = followed === null || !isInside(dir, file) || followed.has(file);
+      if (loaded && !document && content.length <= SCAN_LIMIT && !content.subarray(0, 8e3).includes(0)) {
+        scan(content.toString("utf8").replace(/\\[\\/]/g, "/"), file);
+      }
+    }
+  };
+  const ancestors = upTo(dir, listRoot).slice(1);
+  for (const directory of ancestors) {
+    list(directory, false).forEach(add);
+  }
+  for (const directory of [dir, ...ancestors]) {
+    for (const linked of linkedPackages(path5.join(directory, "node_modules"), listRoot)) {
+      if (!isInside(linked, dir)) {
+        enqueue(linked, path5.join(directory, "node_modules"));
+      }
+    }
+  }
+  const above = withinBounds(listRoot).slice(1);
+  for (const directory of [dir, ...ancestors, ...above]) {
+    const candidates = [
+      ...INSTALL_MARKERS.map((marker) => path5.join(directory, "node_modules", marker)),
+      ...above.includes(directory) ? LOCK_FILES.map((name) => path5.join(directory, name)) : []
+    ];
+    for (const file of candidates) {
+      const hash = hashFile(file);
+      if (hash !== null) {
+        files[toPosix(path5.relative(listRoot, file))] = hash;
+      }
+    }
+  }
+  for (let position = 0; position < regions.length; position += 1) {
+    list(regions[position], true).forEach(add);
+  }
+  const environment = {
+    "Node.js": process.version,
+    platform: `${process.platform} ${process.arch}`,
+    "test-gates": ownVersion()
+  };
+  for (const name of TOOLS) {
+    const version = installedVersion(dir, name);
+    if (version !== null) {
+      environment[name] = version;
+    }
+  }
+  return { snapshot: { mode, environment, args: input.args, files }, root: listRoot, widened };
+}
+
+// src/commands/mutation.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import fs8 from "fs";
+import path8 from "path";
+import { pathToFileURL } from "url";
+
+// src/affected-files.ts
+import fs6 from "fs";
+import { builtinModules as builtinModules2 } from "module";
+import path6 from "path";
+var AffectedError = class extends Error {
+};
+var RUNTIME_PATHS = /\b(?:__dirname|__filename|require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readdirSync)\b|\bimport\.meta\.(?:url|dirname|filename|glob|resolve)\b/;
+var FILE_MODULES = /* @__PURE__ */ new Set([
+  "fs",
+  "fs/promises",
+  "child_process",
+  "module",
+  "worker_threads",
+  "fs-extra",
+  "graceful-fs",
+  "glob",
+  "fast-glob",
+  "globby"
+]);
+var bare = (specifier) => specifier.replace(/^node:/, "");
+function linkedPackage(specifier, from) {
+  const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+  for (let current = path6.dirname(from); ; current = path6.dirname(current)) {
+    const candidate = path6.join(current, "node_modules", name);
+    if (fs6.existsSync(candidate)) {
+      const target = realpath(candidate);
+      return target.split(path6.sep).includes("node_modules") ? null : target;
+    }
+    if (current === path6.dirname(current)) {
+      return null;
+    }
+  }
+}
+var toPosix2 = (file) => file.split(path6.sep).join("/");
+function realpath(file) {
+  try {
+    return fs6.realpathSync.native(file);
+  } catch {
+    return file;
+  }
+}
+function runnerConfigs(dir, stryker, options) {
+  const files = [path6.resolve(dir, stryker)];
+  const named = options.testRunner === "vitest" ? options.vitestConfig : options.jestConfig;
+  if (options.testRunner !== "vitest" && options.testRunner !== "jest") {
+    throw new AffectedError(
+      `--affected knows the test runners jest and vitest, the Stryker config uses ${String(options.testRunner)}`
+    );
+  }
+  if (typeof named === "string") {
+    files.push(path6.resolve(dir, named));
+  } else {
+    const names = options.testRunner === "vitest" ? ["vitest.config", "vite.config"] : ["jest.config"];
+    for (const name of names) {
+      for (const extension of [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"]) {
+        const file = path6.join(dir, name + extension);
+        if (fs6.existsSync(file)) {
+          files.push(file);
         }
-        const target = group[(entry.occurrence ?? 1) - 1];
-        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
-        if (!target || refusal !== null) {
-          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
-          return;
+      }
+    }
+  }
+  return { files: files.filter((file) => fs6.existsSync(file)).map(realpath) };
+}
+function fileEdges(file, context) {
+  const { dir, aliases, cache } = context;
+  const known = cache.get(file);
+  if (known !== void 0) {
+    return known;
+  }
+  const shown = (one) => toPosix2(path6.relative(dir, one));
+  const target = (specifier, from) => {
+    if (specifier.startsWith(".")) {
+      return resolveFile(path6.resolve(path6.dirname(from), specifier));
+    }
+    const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
+    return alias === void 0 ? null : resolveFile(path6.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
+  };
+  const found = { loads: [], unknown: null, computed: false, unnamed: [] };
+  cache.set(file, found);
+  const snapshotFile = path6.join(
+    path6.dirname(file),
+    "__snapshots__",
+    `${path6.basename(file)}.snap`
+  );
+  if (fs6.existsSync(snapshotFile)) {
+    found.loads.push(realpath(snapshotFile));
+  }
+  if (!SCRIPT.test(file) && !COMPONENT.test(file)) {
+    return found;
+  }
+  const source = fs6.readFileSync(file, "utf8");
+  if (COMPONENT.test(file)) {
+    found.unknown = `${shown(file)} is a component, which can use others that it does not import`;
+  }
+  const uncheckable = findUncheckableImports(source)[0];
+  const runtime = RUNTIME_PATHS.exec(source);
+  if (uncheckable !== void 0) {
+    found.unknown = `${shown(file)}:${uncheckable} imports a module whose path is not written out`;
+    found.computed = true;
+  } else if (runtime !== null) {
+    found.unknown = `${shown(file)} uses ${runtime[0]}, which can reach files that no import names`;
+  }
+  const specifiers = /* @__PURE__ */ new Set([
+    ...parseImports(source).map((ref) => ref.module),
+    ...[...source.matchAll(RUNNER_LOAD)].map((match) => match[2])
+  ]);
+  for (const specifier of specifiers) {
+    if (path6.isAbsolute(specifier) || specifier.startsWith("file:")) {
+      const resolved = resolveFile(
+        specifier.startsWith("file:") ? new URL(specifier).pathname : specifier
+      );
+      if (resolved === null) {
+        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+      } else {
+        found.loads.push(realpath(resolved));
+      }
+    } else if (isProjectImport(specifier, aliases)) {
+      const resolved = target(specifier, file);
+      if (resolved === null) {
+        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+      } else {
+        found.loads.push(realpath(resolved));
+      }
+    } else if (FILE_MODULES.has(bare(specifier))) {
+      found.unknown ??= `${shown(file)} imports ${specifier}, which can reach files that no import names`;
+    } else if (!specifier.startsWith("node:") && !builtinModules2.includes(specifier)) {
+      if (!installed(specifier, file)) {
+        found.unknown ??= `${shown(file)} imports ${specifier}, which is neither a file nor an installed package (name an alias in settings.importAliases)`;
+        found.unnamed.push(specifier);
+      } else if (linkedPackage(specifier, file) !== null) {
+        found.unknown ??= `${shown(file)} imports ${specifier}, a package of the repository linked into node_modules`;
+        found.computed = true;
+      }
+    }
+  }
+  for (const match of source.matchAll(QUOTED)) {
+    const text = match[2];
+    if (text.startsWith(".") && !specifiers.has(text)) {
+      const resolved = resolveFile(path6.resolve(path6.dirname(file), text));
+      if (resolved !== null) {
+        found.loads.push(realpath(resolved));
+      }
+    }
+  }
+  return found;
+}
+function affectedInputs(manifest, input) {
+  const dir = realpath(manifest.dir);
+  const aliases = manifest.settings.importAliases;
+  const placed = [...input.tests, ...Object.values(input.covering).flat()];
+  const absolute = placed.find((file) => path6.isAbsolute(file) || file.startsWith(".."));
+  if (absolute !== void 0) {
+    throw new AffectedError(`the report names a spec file outside of the subproject: ${absolute}`);
+  }
+  const keyOf2 = (file) => {
+    const relative = path6.relative(input.root, realpath(file));
+    if (relative.startsWith("..") || path6.isAbsolute(relative)) {
+      throw new AffectedError(`${file} is outside of the files that are compared`);
+    }
+    return toPosix2(relative);
+  };
+  const shown = (file) => toPosix2(path6.relative(dir, file));
+  const edges = /* @__PURE__ */ new Map();
+  const edgesOf = (file) => fileEdges(file, { dir, aliases, cache: edges });
+  const closure = (start, strict) => {
+    const seen = /* @__PURE__ */ new Set([start]);
+    const queue = [start];
+    for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+      const found = edgesOf(file);
+      if (strict && found.unknown !== null) {
+        throw new AffectedError(found.unknown);
+      }
+      for (const next of found.loads) {
+        if (!seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
         }
-        if (claimed.has(target)) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: another ${noun} already covers this mutant`
-          });
-          return;
+      }
+    }
+    return [...seen];
+  };
+  const isCompared = (file) => {
+    const relative = path6.relative(input.root, realpath(file));
+    return !relative.startsWith("..") && !path6.isAbsolute(relative) && toPosix2(relative) in input.files;
+  };
+  const keysOf = (files) => files.map((file) => {
+    const key = keyOf2(file);
+    if (!(key in input.files)) {
+      throw new AffectedError(
+        `${shown(file)} is loaded by a gate or a spec, but is not among the compared files (does git ignore it?)`
+      );
+    }
+    return key;
+  });
+  const config = /* @__PURE__ */ new Set();
+  const named = [];
+  for (const file of input.configs.files) {
+    for (const loaded of closure(file, false).filter(isCompared)) {
+      config.add(loaded);
+      if (!SCRIPT.test(loaded)) {
+        continue;
+      }
+      for (const match of fs6.readFileSync(loaded, "utf8").matchAll(QUOTED)) {
+        const text = match[2].replace(/^<rootDir>\//, "");
+        const found = resolveFile(path6.resolve(path6.dirname(loaded), text), false) ?? resolveFile(path6.resolve(dir, text), false);
+        if (found !== null && !text.includes("*") && isCompared(found)) {
+          named.push(realpath(found));
         }
-        claimed.add(target);
-      });
-      return claimed;
+      }
+    }
+  }
+  const gatePaths = new Map(
+    manifest.gates.map((gate) => [realpath(path6.join(dir, gate.path)), gate.path])
+  );
+  const tests = [
+    .../* @__PURE__ */ new Set([
+      ...input.tests,
+      ...manifest.gates.flatMap((gate) => gate.existingSpecs),
+      ...Object.values(input.covering).flat()
+    ])
+  ];
+  const runAsSuch = new Set(
+    [...tests, ...manifest.gates.map((gate) => gate.path)].map(
+      (file) => realpath(path6.join(dir, file))
+    )
+  );
+  const subprojectKey = toPosix2(path6.relative(input.root, dir));
+  const isConfig = (file) => input.configs.files.includes(file) || kindOf(keyOf2(file), subprojectKey) === "config";
+  for (const file of named.filter((one) => !isConfig(one) && !runAsSuch.has(one))) {
+    for (const loaded of closure(file, true)) {
+      const gate = gatePaths.get(loaded);
+      if (gate !== void 0) {
+        throw new AffectedError(
+          `${gate} is loaded through the test runner config for every spec (${shown(file)})`
+        );
+      }
+      config.add(loaded);
+    }
+  }
+  const fromSubproject = (file) => path6.join(dir, file);
+  const closures = /* @__PURE__ */ Object.create(null);
+  for (const file of [...manifest.gates.map((gate) => gate.path), ...tests]) {
+    const absolute2 = fromSubproject(file);
+    if (!fs6.existsSync(absolute2)) {
+      continue;
+    }
+    closures[keysOf([absolute2])[0]] = keysOf(closure(realpath(absolute2), true));
+  }
+  const keyed = (files) => files.map((file) => toPosix2(path6.relative(input.root, path6.join(dir, file))));
+  const dependencies = gateDependencies({
+    gates: manifest.gates.map((gate) => ({
+      key: keyed([gate.path])[0],
+      specs: keyed(gate.existingSpecs)
+    })),
+    tests: keyed(tests),
+    covering: Object.fromEntries(
+      Object.entries(input.covering).map(([gate, specs]) => [keyed([gate])[0], keyed(specs)])
+    ),
+    closures
+  });
+  const subproject = toPosix2(path6.relative(input.root, dir));
+  const prefix = subproject === "" ? "" : `${subproject}/`;
+  const gates = /* @__PURE__ */ Object.create(null);
+  for (const gate of manifest.gates) {
+    const key = keyed([gate.path])[0];
+    const found = dependencies[key];
+    gates[gate.path] = {
+      key,
+      specs: found.specs.map(
+        (spec) => spec.startsWith(prefix) ? spec.slice(prefix.length) : spec
+      ),
+      files: found.files
     };
-    const allowed = claim(
-      "equivalentMutants",
-      gate.equivalentMutants,
-      "allowance",
-      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
-    );
-    const expected = claim(
-      "expectedTimeouts",
-      gate.expectedTimeouts,
-      "entry",
-      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
-    );
-    for (const entry of located) {
-      const { mutant } = entry;
-      summary.total += 1;
-      if (DETECTED.has(mutant.status)) {
-        summary.detected += 1;
-        if (mutant.status === "Timeout") {
-          summary.timeout += 1;
-          if (expected.has(entry)) {
-            summary.expectedTimeout += 1;
-          } else {
-            unexpectedTimeouts.push(describeMutant(gate.path, entry));
+  }
+  return { subproject, config: keysOf([...config]).sort(), gates };
+}
+var NOT_THE_HELPER2 = "the runner config is not made with createJestGatesConfig or createVitestGatesConfig";
+var OWN = /@t09tanaka\/test-gates\/(?:jest|vitest)\b/;
+var PROJECTS = /\b(?:projects|workspace)\b/;
+var HELPERS = ["createJestGatesConfig", "createVitestGatesConfig"];
+function isHelperResult(text) {
+  const names = new Set(HELPERS);
+  for (const match of text.matchAll(
+    /\b(?:createJestGatesConfig|createVitestGatesConfig)\s*(?::|\bas\b)\s*([\w$]+)/g
+  )) {
+    names.add(match[1]);
+  }
+  const escape = (name2) => name2.replace(/\$/g, "\\$");
+  const call = `(?:defineConfig\\s*\\(\\s*)?(?:${[...names].map(escape).join("|")})\\s*\\(`;
+  const exported = "(?:export\\s+default|module\\.exports\\s*=)\\s*";
+  const reached = (name2) => new RegExp(`\\b${escape(name2)}\\s*(?:\\.|\\[)`).test(text);
+  if (new RegExp(`${exported}${call}`).test(text)) {
+    return !reached("module.exports") && !/\bexports\s*(?:\.|\[)/.test(text.replace(/\bmodule\.exports\s*=/g, ""));
+  }
+  const variable = new RegExp(`\\b(?:const|let|var)\\s+([\\w$]+)\\s*=\\s*${call}`).exec(text);
+  if (variable === null) {
+    return false;
+  }
+  const name = escape(variable[1]);
+  const uses = text.match(new RegExp(`(?<![\\w$.])${name}(?![\\w$])`, "g")) ?? [];
+  return uses.length === 2 && new RegExp(`${exported}${name}\\s*(?:;|$)`, "m").test(text);
+}
+var READ_BY_NAME = [
+  /^test-gates\.json$/,
+  /^[jt]sconfig(?:\..+)?\.json$/,
+  /^babel\.config\.[cm]?[jt]s(?:on)?$/,
+  /^\.babelrc(?:\.[cm]?js(?:on)?)?$/,
+  /^\.swcrc$/
+];
+function loadedScope(manifest, configs, listed2) {
+  const dir = realpath(manifest.dir);
+  const cache = /* @__PURE__ */ new Map();
+  const context = { dir, aliases: manifest.settings.importAliases, cache };
+  const runner = configs.files.slice(1);
+  const texts = runner.map((file) => withoutComments(fs6.readFileSync(file, "utf8")));
+  if (runner.length === 0 || !texts.every((text) => OWN.test(text))) {
+    return { every: NOT_THE_HELPER2 };
+  }
+  if (!texts.every(isHelperResult)) {
+    return {
+      every: "what the runner config exports is not what the helper returns (merged with another config, or changed after the call)"
+    };
+  }
+  const parts = new Set(runner.map(realpath));
+  for (const file of [...parts]) {
+    if (SCRIPT.test(file)) {
+      fileEdges(file, context).loads.forEach((loaded) => parts.add(loaded));
+    }
+  }
+  if ([...parts].some((file) => PROJECTS.test(withoutComments(fs6.readFileSync(file, "utf8"))))) {
+    return {
+      every: "the runner config, or a file it is put together from, names projects or a workspace"
+    };
+  }
+  const named = fs6.readdirSync(dir).filter((name) => READ_BY_NAME.some((pattern) => pattern.test(name))).map((name) => path6.join(dir, name));
+  const mocks = path6.join(dir, "__mocks__");
+  const seeds = [
+    ...configs.files,
+    ...named,
+    ...manifest.gates.flatMap((gate) => [gate.path, ...gate.existingSpecs]).map((file) => path6.join(dir, file)),
+    ...listed2.filter((file) => file.startsWith(`${mocks}${path6.sep}`))
+  ].filter((file) => fs6.existsSync(file)).map(realpath);
+  const naming = new Set(
+    [...configs.files, ...named].filter((file) => fs6.existsSync(file)).map(realpath)
+  );
+  const seen = new Set(seeds);
+  const queue = [...seeds];
+  const add = (file) => {
+    const real = realpath(file);
+    if (!seen.has(real)) {
+      seen.add(real);
+      queue.push(real);
+    }
+  };
+  for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+    if (fs6.statSync(file).isDirectory()) {
+      continue;
+    }
+    const edges = fileEdges(file, context);
+    if (edges.computed) {
+      return { every: edges.unknown ?? "a file loads modules that are not followed" };
+    }
+    edges.loads.forEach(add);
+    for (const specifier of edges.unnamed) {
+      endingAs(specifier, listed2).forEach(add);
+    }
+    const mock = path6.join(path6.dirname(file), "__mocks__", path6.basename(file));
+    if (fs6.existsSync(mock)) {
+      add(mock);
+    }
+    if (naming.has(file) || SCRIPT.test(file) && path6.dirname(file) === dir) {
+      for (const named2 of namedIn(file)) {
+        const text = named2.replace(/^<rootDir>\//, "");
+        const found = resolveFile(path6.resolve(path6.dirname(file), text), false) ?? resolveFile(path6.resolve(dir, text), false);
+        if (found !== null && !text.includes("*")) {
+          if (!SCRIPT.test(found)) {
+            naming.add(realpath(found));
           }
+          add(found);
         }
-      } else if (NOT_EVALUABLE.has(mutant.status)) {
-        summary.notEvaluable += 1;
-      } else if (SURVIVED.has(mutant.status)) {
-        if (allowed.has(entry)) {
-          summary.allowed += 1;
-          continue;
+      }
+    }
+  }
+  return { files: seen };
+}
+function endingAs(specifier, files) {
+  const parts = specifier.split("/");
+  const rest = (parts.length > 1 ? parts.slice(1).join("/") : specifier.replace(/^[@#~$]+/, "")).replace(/\.[cm]?[jt]sx?$/, "");
+  if (rest === "") {
+    return [];
+  }
+  return files.filter((file) => {
+    const bare2 = toPosix2(file).replace(/\.[^./]+$/, "");
+    return [bare2, bare2.replace(/\/index$/, "")].some((one) => one.endsWith(`/${rest}`));
+  });
+}
+function namedIn(file) {
+  const text = fs6.readFileSync(file, "utf8");
+  if (SCRIPT.test(file)) {
+    return [...text.matchAll(QUOTED)].map((match) => match[2]);
+  }
+  return ["extends", "plugins", "presets"].flatMap((key) => valuesOf(text, key));
+}
+function valuesOf(text, key) {
+  const found = [];
+  for (const match of text.matchAll(new RegExp(`"${key}"\\s*:\\s*`, "g"))) {
+    let at = (match.index ?? 0) + match[0].length;
+    if (text[at] === '"') {
+      const end = text.indexOf('"', at + 1);
+      found.push(text.slice(at + 1, end === -1 ? void 0 : end));
+      continue;
+    }
+    if (text[at] !== "[") {
+      continue;
+    }
+    let depth = 0;
+    for (; at < text.length; at += 1) {
+      const char = text[at];
+      if (char === '"') {
+        const end = text.indexOf('"', at + 1);
+        found.push(text.slice(at + 1, end === -1 ? void 0 : end));
+        at = end === -1 ? text.length : end;
+      } else if (char === "[") {
+        depth += 1;
+      } else if (char === "]") {
+        depth -= 1;
+        if (depth === 0) {
+          break;
         }
-        summary.unallowed += 1;
-        survivors.push(describeMutant(gate.path, entry));
-      } else {
-        violations.push({
-          file: gate.path,
-          line: mutant.location.start.line,
-          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
-        });
       }
     }
   }
-  if (summary.total === 0) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: "no mutants were evaluated (the mutation test ran on nothing)"
-    });
+  return found;
+}
+function withoutComments(text) {
+  let out = "";
+  for (let at = 0; at < text.length; at += 1) {
+    const char = text[at];
+    if (char === "'" || char === '"' || char === "`") {
+      let end = at + 1;
+      while (end < text.length && text[end] !== char && text[end] !== "\n") {
+        end += text[end] === "\\" ? 2 : 1;
+      }
+      out += text.slice(at, end + 1);
+      at = end;
+    } else if (char === "/" && text[at + 1] === "/") {
+      const end = text.indexOf("\n", at);
+      at = end === -1 ? text.length : end - 1;
+    } else if (char === "/" && text[at + 1] === "*") {
+      const end = text.indexOf("*/", at + 2);
+      at = end === -1 ? text.length : end + 1;
+    } else {
+      out += char;
+    }
+  }
+  return out;
+}
+
+// src/commands/mutation-result.ts
+import fs7 from "fs";
+import path7 from "path";
+
+// src/core/mutation-result.ts
+var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
+var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
+function normalizeCode(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizePath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function sliceByLocation(source, location) {
+  const lines = source.split("\n");
+  const { start, end } = location;
+  const first = lines[start.line - 1];
+  const last = lines[end.line - 1];
+  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+    return null;
+  }
+  if (start.line === end.line) {
+    return first.slice(start.column - 1, end.column - 1);
+  }
+  return [
+    first.slice(start.column - 1),
+    ...lines.slice(start.line, end.line - 1),
+    last.slice(0, end.column - 1)
+  ].join("\n");
+}
+function keyOf(mutator, original, replacement) {
+  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+}
+function describeMutant(file, entry) {
+  const { mutant } = entry;
+  return {
+    file,
+    line: mutant.location.start.line,
+    column: mutant.location.start.column,
+    status: mutant.status,
+    mutator: mutant.mutatorName,
+    original: normalizeCode(entry.original),
+    replacement: normalizeCode(entry.replacement),
+    occurrence: entry.occurrence,
+    sameKeyCount: entry.sameKeyCount,
+    allowance: {
+      mutator: mutant.mutatorName,
+      original: normalizeCode(entry.original),
+      replacement: normalizeCode(entry.replacement),
+      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
+      reason: ""
+    }
+  };
+}
+function describeAllowance(entry) {
+  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
+  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+}
+function judgeMutationReport(input) {
+  const violations = [];
+  const survivors = [];
+  const unexpectedTimeouts = [];
+  const summary = {
+    total: 0,
+    detected: 0,
+    timeout: 0,
+    allowed: 0,
+    notEvaluable: 0,
+    unallowed: 0,
+    expectedTimeout: 0
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, result] of Object.entries(input.report.files ?? {})) {
+    files.set(normalizePath(file), result);
+  }
+  for (const gate of input.gates) {
+    const gatePath = normalizePath(gate.path);
+    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
+    violations.push(...shapeViolations);
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
+    const result = files.get(gatePath);
+    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: "no mutants in the report (the gate was not mutation tested)"
+      });
+      continue;
+    }
+    const diskSource = input.readSource(gate.path);
+    const source = result.source ?? diskSource;
+    if (source === void 0) {
+      violations.push({
+        file: gate.path,
+        message: "source is neither in the report nor readable on disk"
+      });
+      continue;
+    }
+    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
+      violations.push({
+        file: gate.path,
+        message: "the report was made from a different version of this file. Run Stryker again"
+      });
+      continue;
+    }
+    const located = [];
+    const byKey = /* @__PURE__ */ new Map();
+    const sorted2 = [...result.mutants].sort(
+      (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
+    );
+    let locationsValid = true;
+    for (const mutant of sorted2) {
+      const original = sliceByLocation(normalizeNewlines(source), mutant.location);
+      if (original === null) {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
+        });
+        locationsValid = false;
+        continue;
+      }
+      const replacement = mutant.replacement ?? "";
+      const key = keyOf(mutant.mutatorName, original, replacement);
+      const group = byKey.get(key) ?? [];
+      const entry = {
+        mutant,
+        original,
+        replacement,
+        occurrence: group.length + 1,
+        sameKeyCount: 0
+      };
+      group.push(entry);
+      byKey.set(key, group);
+      located.push(entry);
+    }
+    for (const group of byKey.values()) {
+      for (const entry of group) {
+        entry.sameKeyCount = group.length;
+      }
+    }
+    if (!locationsValid) {
+      continue;
+    }
+    const claim = (field, entries, noun, accept) => {
+      const claimed = /* @__PURE__ */ new Set();
+      if (!Array.isArray(entries)) {
+        return claimed;
+      }
+      entries.forEach((entry, index) => {
+        if (!isUsableEquivalentMutant(entry)) {
+          return;
+        }
+        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
+        const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
+        if (entry.occurrence === void 0 && group.length > 1) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
+          });
+          return;
+        }
+        const target = group[(entry.occurrence ?? 1) - 1];
+        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
+        if (!target || refusal !== null) {
+          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
+          return;
+        }
+        if (claimed.has(target)) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: another ${noun} already covers this mutant`
+          });
+          return;
+        }
+        claimed.add(target);
+      });
+      return claimed;
+    };
+    const allowed = claim(
+      "equivalentMutants",
+      gate.equivalentMutants,
+      "allowance",
+      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
+    );
+    const expected = claim(
+      "expectedTimeouts",
+      gate.expectedTimeouts,
+      "entry",
+      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
+    );
+    for (const entry of located) {
+      const { mutant } = entry;
+      summary.total += 1;
+      if (DETECTED.has(mutant.status)) {
+        summary.detected += 1;
+        if (mutant.status === "Timeout") {
+          summary.timeout += 1;
+          if (expected.has(entry)) {
+            summary.expectedTimeout += 1;
+          } else {
+            unexpectedTimeouts.push(describeMutant(gate.path, entry));
+          }
+        }
+      } else if (NOT_EVALUABLE.has(mutant.status)) {
+        summary.notEvaluable += 1;
+      } else if (SURVIVED.has(mutant.status)) {
+        if (allowed.has(entry)) {
+          summary.allowed += 1;
+          continue;
+        }
+        summary.unallowed += 1;
+        survivors.push(describeMutant(gate.path, entry));
+      } else {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
+        });
+      }
+    }
+  }
+  if (summary.total === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "no mutants were evaluated (the mutation test ran on nothing)"
+    });
+  }
+  const maxTimeouts = input.maxTimeouts ?? 0;
+  if (unexpectedTimeouts.length > maxTimeouts) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
+    });
+  }
+  return { violations, survivors, unexpectedTimeouts, summary };
+}
+function formatSurvivor(survivor) {
+  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
+  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+}
+function formatSummary(summary) {
+  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+}
+
+// src/commands/mutation-result.ts
+function reportPathOf(manifest, override) {
+  return path7.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+}
+function runMutationResult(dir, reportOverride, io2, only = [], seen = () => void 0) {
+  const manifest = readManifest(dir);
+  const gates = only.length === 0 ? manifest.gates : manifest.gates.filter((gate) => only.includes(gate.path));
+  const caveat = only.length === 0 ? "" : gateRunCaveat(gates.length, manifest.gates.length);
+  const reportPath = reportPathOf(manifest, reportOverride);
+  const shown = path7.relative(manifest.dir, reportPath) || reportPath;
+  let report;
+  try {
+    report = JSON.parse(fs7.readFileSync(reportPath, "utf8"));
+  } catch (error) {
+    io2.err(
+      `test-gates mutation: cannot read the Stryker JSON report ${shown} (${error.message}). Did Stryker finish, with the "json" reporter writing to this path?`
+    );
+    return 1;
+  }
+  if (typeof report !== "object" || report === null) {
+    io2.err(`test-gates mutation: ${shown} is not a Stryker JSON report`);
+    return 1;
+  }
+  const verdict = judgeMutationReport({
+    gates,
+    report,
+    maxTimeouts: manifest.settings.maxTimeouts,
+    readSource: (gatePath) => {
+      try {
+        return fs7.readFileSync(path7.join(manifest.dir, gatePath), "utf8");
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  seen({ report, verdict });
+  const summary = formatSummary(verdict.summary);
+  if (verdict.violations.length === 0 && verdict.survivors.length === 0) {
+    io2.out(`test-gates mutation: OK (${summary})${caveat}`);
+    return 0;
+  }
+  if (verdict.survivors.length > 0) {
+    io2.err(
+      `test-gates mutation: ${verdict.survivors.length} surviving mutant(s) not in the allow list`
+    );
+    for (const survivor of verdict.survivors) {
+      io2.err(`  - ${formatSurvivor(survivor)}`);
+    }
+    io2.err("");
+    io2.err(
+      "Fix the test so that it detects the mutant. Only when the mutant cannot be observed from"
+    );
+    io2.err("outside (same return value, exception and side effects for every input), add it to");
+    io2.err('"equivalentMutants" of the gate in test-gates.json and fill in "reason":');
+    const byFile = /* @__PURE__ */ new Map();
+    for (const survivor of verdict.survivors) {
+      byFile.set(survivor.file, [...byFile.get(survivor.file) ?? [], survivor]);
+    }
+    for (const [file, survivors] of byFile) {
+      io2.err("");
+      io2.err(`  ${file}`);
+      survivors.forEach((survivor, index) => {
+        const comma = index === survivors.length - 1 ? "" : ",";
+        io2.err(`    ${JSON.stringify(survivor.allowance)}${comma}`);
+      });
+    }
+    io2.err("");
+  }
+  const maxTimeouts = manifest.settings.maxTimeouts;
+  if (verdict.unexpectedTimeouts.length > maxTimeouts) {
+    io2.err(
+      `test-gates mutation: ${verdict.unexpectedTimeouts.length} mutant(s) timed out (settings.mutation.maxTimeouts: ${maxTimeouts})`
+    );
+    for (const mutant of verdict.unexpectedTimeouts) {
+      io2.err(`  - ${formatSurvivor(mutant)}`);
+    }
+    io2.err("");
+    io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
+    io2.err("can time out instead. Run again with less load (-- --concurrency 1). Only for a");
+    io2.err("mutant that can never finish (a loop that no longer ends), add it to");
+    io2.err('"expectedTimeouts" of the gate in test-gates.json and fill in "reason"');
+    io2.err("(settings.mutation.maxTimeouts raises the limit for the whole project):");
+    for (const mutant of verdict.unexpectedTimeouts) {
+      io2.err(`    ${mutant.file}: ${JSON.stringify(mutant.allowance)}`);
+    }
+    io2.err("");
+  }
+  if (verdict.violations.length > 0) {
+    printViolations(io2, "mutation", verdict.violations);
+  }
+  io2.err(`test-gates mutation: FAILED (${summary})${caveat}`);
+  return 1;
+}
+
+// src/commands/mutation.ts
+var CONFIG_MARK = "\0test-gates-stryker-config\0";
+function loadStrykerConfig(manifest, config) {
+  const file = path8.resolve(manifest.dir, config);
+  if (file.endsWith(".json")) {
+    try {
+      return JSON.parse(fs8.readFileSync(file, "utf8"));
+    } catch {
+      return void 0;
+    }
+  }
+  const script = `const loaded = await import(${JSON.stringify(pathToFileURL(file).href)});const config = loaded.default?.default ?? loaded.default ?? loaded;process.stdout.write(${JSON.stringify(CONFIG_MARK)} + JSON.stringify({incremental: config.incremental, force: config.force,incrementalFile: config.incrementalFile, tempDirName: config.tempDirName,testRunner: config.testRunner, vitestConfig: config.vitest?.configFile,jestConfig: config.jest?.configFile,}) + ${JSON.stringify(CONFIG_MARK)});`;
+  const result = spawnSync2(process.execPath, ["--input-type=module", "--eval", script], {
+    cwd: manifest.dir,
+    encoding: "utf8",
+    timeout: 6e4
+  });
+  const printed = result.stdout?.split(CONFIG_MARK)[1];
+  if (result.status !== 0 || printed === void 0) {
+    return void 0;
+  }
+  return JSON.parse(printed);
+}
+function modifiedAt(file) {
+  try {
+    const stat = fs8.statSync(file, { bigint: true });
+    return `${stat.mtimeNs} ${stat.ino}`;
+  } catch {
+    return null;
+  }
+}
+function guardRecordPath(incrementalFile) {
+  return `${incrementalFile}.test-gates.json`;
+}
+function coveringSpecs(report, gates) {
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
+    for (const test of entry.tests ?? []) {
+      fileOf.set(test.id, file);
+    }
+  }
+  const covering = /* @__PURE__ */ Object.create(null);
+  for (const gate of gates) {
+    const specs = /* @__PURE__ */ new Set();
+    let placed = true;
+    const key = withoutDots(gate);
+    for (const mutant of report.files?.[key]?.mutants ?? []) {
+      for (const id of [...mutant.coveredBy ?? [], ...mutant.killedBy ?? []]) {
+        const file = fileOf.get(id);
+        if (file === void 0) {
+          placed = false;
+        } else {
+          specs.add(file);
+        }
+      }
+    }
+    covering[gate] = placed ? [...specs].sort() : null;
+  }
+  return covering;
+}
+function decideReuse(manifest, config, strykerArgs, part, affected) {
+  const loaded = loadStrykerConfig(manifest, config);
+  const options = incrementalOptions(loaded, strykerArgs);
+  const base = fs8.realpathSync(manifest.dir);
+  const configs = () => runnerConfigs(base, config, loaded ?? {});
+  const decision = {
+    incremental: false,
+    incrementalFile: null,
+    recordFile: null,
+    incrementalHash: null,
+    forced: options.force,
+    snapshot: null,
+    failure: null,
+    root: base,
+    widened: [],
+    scope: null,
+    force: null,
+    plan: null,
+    last: void 0,
+    ci: affected ? affectedRefused(process.env) : null,
+    configs
+  };
+  if (loaded !== void 0 && !options.incremental) {
+    return decision;
+  }
+  decision.incremental = true;
+  const incrementalFile = path8.resolve(base, options.incrementalFile);
+  const recordFile = guardRecordPath(incrementalFile);
+  decision.incrementalFile = incrementalFile;
+  decision.recordFile = recordFile;
+  let snapshot = null;
+  let root = base;
+  let failure = "the Stryker config could not be loaded to see where the incremental file is";
+  if (loaded !== void 0) {
+    const scope = (listed2) => {
+      try {
+        const found = loadedScope(manifest, configs(), listed2);
+        decision.scope = "files" in found ? { files: found.files.size } : found;
+        return "files" in found ? found.files : null;
+      } catch (error) {
+        decision.scope = { every: error.message };
+        return null;
+      }
+    };
+    try {
+      let widened;
+      ({ snapshot, root, widened } = snapshotOf({
+        scope,
+        dir: manifest.dir,
+        written: [
+          incrementalFile,
+          recordFile,
+          path8.resolve(base, options.tempDirName),
+          path8.resolve(base, manifest.settings.strykerReportFile)
+        ],
+        args: comparableArgs(strykerArgs)
+      }));
+      decision.widened = widened;
+    } catch (error) {
+      failure = `the files the run depends on could not be listed (${error.message})`;
+    }
+  }
+  decision.snapshot = snapshot;
+  decision.failure = snapshot === null ? failure : null;
+  decision.root = root;
+  const incremental = hashFile(incrementalFile);
+  decision.incrementalHash = incremental;
+  if (part) {
+    decision.force = incremental !== null && !options.force ? "with --gate nothing is taken over from an earlier run" : null;
+    return decision;
+  }
+  let stored;
+  try {
+    stored = JSON.parse(fs8.readFileSync(recordFile, "utf8"));
+  } catch {
+    stored = void 0;
+  }
+  const ci = decision.ci;
+  let force = null;
+  let plan = null;
+  let last;
+  if (incremental !== null && !options.force) {
+    if (snapshot === null) {
+      force = failure;
+    } else if (!affected) {
+      force = refuseReuse({ record: stored, incremental, snapshot });
+    } else if (ci !== null) {
+      force = ci;
+    } else {
+      const read2 = readRecord({ record: stored, incremental, snapshot });
+      if ("refused" in read2) {
+        force = read2.refused;
+      } else {
+        last = read2.record.affected;
+        try {
+          const inputs = affectedInputs(manifest, {
+            root,
+            files: snapshot.files,
+            configs: configs(),
+            tests: last?.tests ?? [],
+            covering: Object.fromEntries(
+              Object.entries(last?.gates ?? {}).map(([gate, entry]) => [gate, entry.specs])
+            )
+          });
+          plan = planAffected({
+            before: { files: read2.record.snapshot.files, affected: last },
+            now: snapshot.files,
+            subproject: inputs.subproject,
+            config: inputs.config,
+            gates: manifest.gates.map((gate) => ({
+              path: gate.path,
+              files: inputs.gates[gate.path]?.files ?? []
+            }))
+          });
+        } catch (error) {
+          if (!(error instanceof AffectedError)) {
+            throw error;
+          }
+          plan = { full: `what a gate depends on cannot be told: ${error.message}` };
+        }
+        if ("full" in plan) {
+          force = plan.full;
+        }
+      }
+    }
+  } else if (affected && incremental === null && !options.force) {
+    force = "there is no incremental file of an earlier run";
+  }
+  decision.force = force;
+  decision.plan = plan;
+  decision.last = last;
+  return decision;
+}
+function guardIncremental(manifest, config, strykerArgs, part, affected) {
+  const nothing = { force: null, mutate: null, said: [], record: () => void 0 };
+  const decision = decideReuse(manifest, config, strykerArgs, part, affected);
+  if (!decision.incremental) {
+    return affected ? {
+      ...nothing,
+      said: [
+        "test-gates mutation --affected: Stryker does not run in incremental mode, so every mutant is run"
+      ]
+    } : nothing;
+  }
+  const { snapshot, root, plan, last, ci, configs, force } = decision;
+  const incrementalFile = decision.incrementalFile;
+  const recordFile = decision.recordFile;
+  const incremental = decision.incrementalHash;
+  const options = { force: decision.forced };
+  if (part) {
+    fs8.rmSync(recordFile, { force: true });
+    return { ...nothing, force };
+  }
+  fs8.rmSync(recordFile, { force: true });
+  const before = modifiedAt(incrementalFile);
+  const rerun = plan !== null && "rerun" in plan ? plan.rerun.map((entry) => entry.gate) : null;
+  const everyGate = force ?? (rerun !== null && rerun.length > 0 && rerun.length === manifest.gates.length ? "every gate is affected" : null);
+  let ranges = [];
+  if (everyGate === null && incremental !== null && !options.force) {
+    const kept = rerun === null ? manifest.gates.map((gate) => gate.path) : manifest.gates.map((gate) => gate.path).filter((gate) => !rerun.includes(gate));
+    try {
+      ranges = timeoutRanges(
+        JSON.parse(fs8.readFileSync(incrementalFile, "utf8")),
+        kept
+      );
+    } catch {
+      ranges = [];
+    }
+  }
+  const subset = rerun !== null && rerun.length > 0 && everyGate === null ? rerun : [];
+  let said = [];
+  if (affected && !options.force) {
+    if (force !== null) {
+      said = describePlan({ full: force });
+    } else if (plan !== null) {
+      said = describePlan(plan, 5, ranges.length);
+    }
+  } else if (ranges.length > 0) {
+    said = [
+      `test-gates mutation: ${ranges.length} mutant(s) that timed out in the last run are run again, the other results are reused`
+    ];
+  }
+  return {
+    // Every gate is run again: the same as a run of every mutant.
+    force: everyGate,
+    mutate: subset.length + ranges.length > 0 ? [...subset, ...ranges] : null,
+    said,
+    record: (judged) => {
+      const written = hashFile(incrementalFile);
+      if (snapshot === null || written === null || modifiedAt(incrementalFile) === before) {
+        return;
+      }
+      const record = { format: RECORD_FORMAT, incremental: written, snapshot };
+      if (affected && ci === null && judged !== null) {
+        record.affected = affectedRecord(judged, rerun, last);
+      }
+      try {
+        fs8.writeFileSync(recordFile, `${JSON.stringify(record)}
+`);
+      } catch {
+      }
+    }
+  };
+  function affectedRecord(judged, ran, previous) {
+    const gates = manifest.gates.map((gate) => gate.path);
+    const dirty = new Set(
+      [...judged.verdict.survivors, ...judged.verdict.unexpectedTimeouts].map((one) => one.file)
+    );
+    const fresh = coveringSpecs(judged.report, gates);
+    const covering = /* @__PURE__ */ Object.create(null);
+    for (const gate of gates) {
+      const specs = ran === null || ran.includes(gate) ? fresh[gate] : previous?.gates[gate]?.specs ?? null;
+      if (specs !== null && specs !== void 0 && !dirty.has(gate)) {
+        covering[gate] = specs;
+      }
+    }
+    try {
+      const inputs = affectedInputs(manifest, {
+        root,
+        files: snapshot.files,
+        configs: configs(),
+        tests: Object.keys(judged.report.testFiles ?? {}),
+        covering
+      });
+      const recorded = /* @__PURE__ */ Object.create(null);
+      for (const gate of Object.keys(covering)) {
+        const entry = inputs.gates[gate];
+        if (entry !== void 0) {
+          recorded[gate] = { specs: entry.specs, files: entry.files };
+        }
+      }
+      return { tests: Object.keys(judged.report.testFiles ?? {}).sort(), gates: recorded };
+    } catch (error) {
+      if (error instanceof AffectedError) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+}
+function runMutation(dir, strykerArgs, io2, only = [], affected = false) {
+  const part = only.length > 0;
+  if (affected && strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
+    throw new UsageError(
+      "--affected and --mutate cannot be combined: --affected sets --mutate itself"
+    );
+  }
+  if (part) {
+    const refused = gateRunRefused(process.env);
+    if (refused !== null) {
+      throw new UsageError(refused);
+    }
+    if (strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
+      throw new UsageError("--gate and --mutate cannot be combined: --gate sets --mutate itself");
+    }
+  }
+  const manifest = readManifest(dir);
+  const chosen = selectControls({
+    gates: manifest.gates.map((gate) => gate.path),
+    mode: "all",
+    only,
+    shard: null
+  });
+  if ("error" in chosen) {
+    throw new UsageError(chosen.error);
+  }
+  const config = findStrykerConfig(manifest);
+  if (config === null) {
+    throw new ManifestError(
+      "no Stryker config found (stryker.gates.config.mjs). Create one, or set settings.stryker.configFile"
+    );
+  }
+  const stryker = findLocalBin(manifest.dir, "stryker");
+  if (stryker === null) {
+    throw new ManifestError(
+      "stryker is not installed in this project (node_modules/.bin/stryker). Add @stryker-mutator/core as a devDependency"
+    );
+  }
+  const reportFile = reportPathOf(manifest, null);
+  fs8.rmSync(reportFile, { force: true });
+  const guard = guardIncremental(manifest, config, strykerArgs, part, affected);
+  if (guard.said.length > 0) {
+    guard.said.forEach((line) => io2.out(line));
+  } else if (guard.force !== null) {
+    io2.out(
+      `test-gates mutation: running every mutant again (--force), the results of the last run are not reused: ${guard.force}`
+    );
+  }
+  const guardArgs = guard.force === null && guard.mutate === null ? [] : ["--force"];
+  const partArgs = part ? ["--mutate", chosen.selected.join(",")] : guard.mutate !== null ? ["--mutate", guard.mutate.join(",")] : [];
+  const result = spawnSync2(stryker, ["run", config, ...strykerArgs, ...partArgs, ...guardArgs], {
+    cwd: manifest.dir,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.error) {
+    io2.err(`test-gates mutation: cannot start Stryker (${result.error.message})`);
+    return 1;
+  }
+  if (result.status !== 0) {
+    io2.err(
+      `test-gates mutation: Stryker failed (${result.signal ? `signal ${result.signal}` : `exit ${result.status}`}). The result was not judged`
+    );
+    return 1;
+  }
+  let judged = null;
+  const status = runMutationResult(dir, null, io2, part ? chosen.selected : [], (seen) => {
+    judged = seen;
+  });
+  guard.record(judged);
+  if (part) {
+    fs8.rmSync(reportFile, { force: true });
+  }
+  return status;
+}
+
+// src/commands/doctor.ts
+function read(file) {
+  try {
+    return fs9.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function git2(dir, args) {
+  const result = spawnSync3("git", args, {
+    cwd: dir,
+    env: gitEnvironment(process.env),
+    encoding: "utf8"
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+function hooksOf(dir) {
+  const root = git2(dir, ["rev-parse", "--show-toplevel"]) ?? dir;
+  const hooksDir = git2(dir, ["rev-parse", "--path-format=absolute", "--git-path", "hooks"]);
+  const candidates = [
+    ...["pre-push", "pre-commit"].map((name) => path9.join(root, ".husky", name)),
+    ...hooksDir === null ? [] : ["pre-push", "pre-commit"].map((name) => path9.join(hooksDir, name)),
+    ...["lefthook.yml", ".lefthook.yml"].map((name) => path9.join(root, name))
+  ];
+  let script = "";
+  try {
+    const manifest = JSON.parse(read(path9.join(dir, "package.json")) ?? "{}");
+    script = manifest.scripts?.["test:gates:mutation"] ?? "";
+  } catch {
+  }
+  const subproject = path9.relative(fs9.realpathSync(root), dir).split(path9.sep).join("/");
+  const seen = /* @__PURE__ */ new Set();
+  const uses = [];
+  for (const file of candidates) {
+    const text = read(file);
+    if (text === null) {
+      continue;
+    }
+    const real = fs9.realpathSync(file);
+    if (seen.has(real)) {
+      continue;
+    }
+    seen.add(real);
+    const shown = path9.relative(root, file).split(path9.sep).join("/");
+    uses.push(...hookUses({ file: shown, text, subproject, script }));
+  }
+  return uses;
+}
+function runDoctor(dir, io2) {
+  const manifest = readManifest(dir);
+  const config = findStrykerConfig(manifest);
+  if (config === null) {
+    throw new ManifestError(
+      "no Stryker config found (stryker.gates.config.mjs). Create one, or set settings.stryker.configFile"
+    );
+  }
+  const plain2 = decideReuse(manifest, config, [], false, false);
+  const affected = decideReuse(manifest, config, [], false, true);
+  io2.out(`test-gates doctor: ${manifest.dir} (${config})`);
+  if (plain2.snapshot !== null) {
+    const subproject = path9.relative(plain2.root, fs9.realpathSync(manifest.dir));
+    const prefix = subproject === "" ? "" : `${subproject.split(path9.sep).join("/")}/`;
+    const keys = Object.keys(plain2.snapshot.files);
+    const outside = keys.filter((key) => !key.startsWith(prefix)).length;
+    const followed = plain2.scope === null ? "" : "files" in plain2.scope ? `, paths followed in the ${plain2.scope.files} files the run loads` : ", paths followed in every file";
+    io2.out(`  compared: ${keys.length} files, ${outside} outside the subproject${followed}`);
+  }
+  if (plain2.incremental) {
+    const reuse = plain2.forced ? "the Stryker config sets force" : plain2.force ?? (plain2.incrementalHash === null ? "there is no incremental file of an earlier run" : null);
+    io2.out(
+      reuse === null ? "  next run: reuses the results of the last run" : `  next run: every mutant, ${reuse}`
+    );
+    if (affected.ci !== null) {
+      io2.out(`  next run with --affected: every mutant, ${affected.ci}`);
+    } else if (affected.plan !== null && "rerun" in affected.plan) {
+      const [first = "", ...rest] = describePlan(affected.plan);
+      io2.out(
+        `  next run with --affected: ${first.replace(/^test-gates mutation --affected: /, "")}`
+      );
+      rest.forEach((line) => io2.out(`  ${line}`));
+    } else {
+      const why = affected.forced ? "the Stryker config sets force" : affected.force;
+      io2.out(`  next run with --affected: every mutant, ${why ?? "there is nothing to reuse"}`);
+    }
+  }
+  const { lines, status } = formatFindings(
+    diagnose({
+      incremental: plain2.incremental,
+      forced: plain2.forced,
+      failure: plain2.failure,
+      widened: plain2.widened,
+      scope: plain2.scope,
+      hooks: hooksOf(fs9.realpathSync(manifest.dir))
+    })
+  );
+  lines.forEach((line) => io2.out(line));
+  return status;
+}
+
+// src/commands/lcov.ts
+import fs10 from "fs";
+import path10 from "path";
+
+// src/core/lcov.ts
+function normalizePath2(file, rootDir) {
+  let normalized = file.replace(/\\/g, "/");
+  if (rootDir !== void 0) {
+    const root = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized.startsWith(`${root}/`)) {
+      normalized = normalized.slice(root.length + 1);
+    }
+  }
+  return normalized.replace(/^\.\//, "");
+}
+function parseLcov(text, rootDir) {
+  const files = /* @__PURE__ */ new Map();
+  let record = null;
+  const closeRecord = () => {
+    if (record && !record.hasDa) {
+      record.file.found += record.found;
+      record.file.hit += record.hit;
+    }
+    record = null;
+  };
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line.startsWith("SF:")) {
+      closeRecord();
+      const path13 = normalizePath2(line.slice(3), rootDir);
+      const file = files.get(path13) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path13, file);
+      record = { file, hasDa: false, found: 0, hit: 0 };
+    } else if (line === "end_of_record") {
+      closeRecord();
+    } else if (record) {
+      const open = record;
+      if (line.startsWith("DA:")) {
+        const [lineNumber, hits] = line.slice(3).split(",");
+        const number = Number(lineNumber);
+        const count = Number(hits);
+        if (Number.isInteger(number) && Number.isFinite(count)) {
+          open.hasDa = true;
+          open.file.lines.set(number, Math.max(open.file.lines.get(number) ?? 0, count));
+        }
+      } else if (line.startsWith("LF:")) {
+        open.found = Number(line.slice(3)) || 0;
+      } else if (line.startsWith("LH:")) {
+        open.hit = Number(line.slice(3)) || 0;
+      }
+    }
+  }
+  closeRecord();
+  const result = /* @__PURE__ */ new Map();
+  for (const [file, accumulator] of files) {
+    const uncovered = [...accumulator.lines.entries()].filter(([, hits]) => hits <= 0).map(([lineNumber]) => lineNumber).sort((a, b) => a - b);
+    result.set(file, {
+      found: accumulator.lines.size + accumulator.found,
+      hit: accumulator.lines.size - uncovered.length + accumulator.hit,
+      uncovered
+    });
+  }
+  return result;
+}
+function judgeLcov(gatePaths, coverage) {
+  const violations = [];
+  const results = [];
+  for (const gatePath of gatePaths) {
+    const file = coverage.get(normalizePath2(gatePath));
+    if (!file) {
+      violations.push({ file: gatePath, message: "no record in the lcov file" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    if (file.found === 0) {
+      violations.push({ file: gatePath, message: "no instrumented lines in the lcov record" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    const ok = file.hit === file.found;
+    if (!ok) {
+      const shown = file.uncovered.slice(0, 20).join(", ");
+      const more = file.uncovered.length > 20 ? ", \u2026" : "";
+      violations.push({
+        file: gatePath,
+        ...file.uncovered[0] === void 0 ? {} : { line: file.uncovered[0] },
+        message: `${file.hit}/${file.found} lines covered` + (shown === "" ? "" : ` (uncovered: ${shown}${more})`)
+      });
+    }
+    results.push({ path: gatePath, found: file.found, hit: file.hit, ok });
+  }
+  return { violations, results };
+}
+function summarizeLcov(coverage, exclude) {
+  let found = 0;
+  let hit = 0;
+  for (const [file, lines] of coverage) {
+    if (exclude.some((regex) => regex.test(file))) {
+      continue;
+    }
+    found += lines.found;
+    hit += lines.hit;
+  }
+  return { found, hit };
+}
+
+// src/commands/lcov.ts
+function runLcov(dir, fileOption, io2) {
+  const manifest = readManifest(dir);
+  const file = fileOption ?? manifest.settings.lcovFile;
+  if (file === null) {
+    throw new ManifestError(
+      "no lcov file given. Pass --file <lcov.info> or set settings.lcov.file"
+    );
+  }
+  const lcovPath = path10.resolve(manifest.dir, file);
+  let text;
+  try {
+    text = fs10.readFileSync(lcovPath, "utf8");
+  } catch (error) {
+    io2.err(
+      `test-gates lcov: cannot read ${file} (${error.message}). Run the tests with coverage first`
+    );
+    return 1;
+  }
+  const violations = [...manifest.violations];
+  const listing = /* @__PURE__ */ new Map();
+  const existing = manifest.gates.filter((gate) => {
+    const exists = existsExact(manifest.dir, gate.path, "file", listing);
+    if (!exists) {
+      violations.push({
+        file: gate.path,
+        message: "file not found (the check is case-sensitive). Update test-gates.json if it moved"
+      });
+    }
+    return exists;
+  });
+  const coverage = parseLcov(text, manifest.dir);
+  const total = summarizeLcov(coverage, manifest.settings.lcovSummaryExclude);
+  io2.out(
+    total.found === 0 ? "reference: no instrumented lines in the lcov file" : `reference: overall line coverage ${(total.hit / total.found * 100).toFixed(2)}% (${total.hit}/${total.found}, not gated)`
+  );
+  const verdict = judgeLcov(
+    existing.map((gate) => gate.path),
+    coverage
+  );
+  for (const result of verdict.results) {
+    if (result.ok) {
+      io2.out(`  \u2713 ${result.path}: ${result.hit}/${result.found} lines`);
+    }
+  }
+  violations.push(...verdict.violations);
+  if (violations.length > 0) {
+    printViolations(io2, "lcov", violations);
+    return 1;
+  }
+  io2.out(`test-gates lcov: OK (${verdict.results.length} gate(s) at 100% line coverage)`);
+  return 0;
+}
+
+// src/commands/selfcheck.ts
+import { spawn, spawnSync as spawnSync4 } from "child_process";
+import fs12 from "fs";
+import os2 from "os";
+import path12 from "path";
+
+// src/core/jobs.ts
+var SWITCHES = {
+  jest: ["--runInBand", "-i", "--ci"],
+  vitest: ["--no-file-parallelism", "--fileParallelism=false", "--pool=forks", "--pool=threads"]
+};
+var COUNTS = {
+  jest: ["--maxWorkers", "-w"],
+  vitest: ["--maxWorkers", "--minWorkers"]
+};
+var COUNT = /^\d+%?$/;
+function knownCommand(program, args) {
+  const runner = ["jest", "vitest"].find((name) => name === program);
+  if (runner === void 0) {
+    return { stray: program };
+  }
+  if (runner === "vitest" && args[0] !== "run") {
+    return { stray: args[0] ?? 'vitest without "run"' };
   }
-  const maxTimeouts = input.maxTimeouts ?? 0;
-  if (unexpectedTimeouts.length > maxTimeouts) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
-    });
+  const rest = runner === "vitest" ? args.slice(1) : [...args];
+  let configs = 0;
+  for (let arg = rest.shift(); arg !== void 0; arg = rest.shift()) {
+    if (SWITCHES[runner].includes(arg)) {
+      continue;
+    }
+    const equals = arg.indexOf("=");
+    const name = equals === -1 ? arg : arg.slice(0, equals);
+    const value = equals === -1 ? rest.shift() : arg.slice(equals + 1);
+    if (value !== void 0 && (name === "--config" || name === "-c")) {
+      configs += 1;
+    } else if (!COUNTS[runner].includes(name) || !COUNT.test(String(value))) {
+      return { stray: arg };
+    }
   }
-  return { violations, survivors, unexpectedTimeouts, summary };
-}
-function formatSurvivor(survivor) {
-  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
-  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+  return configs === 1 ? { runner } : { stray: configs === 0 ? "no --config" : "two --config" };
 }
-function formatSummary(summary) {
-  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+function jobFlags(runner, dir) {
+  return runner === "jest" ? [`--coverageDirectory=${dir}/coverage`, `--cacheDirectory=${dir}/cache`] : [`--coverage.reportsDirectory=${dir}/coverage`, "--no-cache"];
 }
-
-// src/commands/mutation-result.ts
-function reportPathOf(manifest, override) {
-  return path5.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+var REACHES = [
+  "process.",
+  "process?.",
+  "process[",
+  "globalThis",
+  "global.",
+  "global[",
+  "import.meta.env",
+  "Date.now",
+  "Date()",
+  "performance.now",
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "waitFor",
+  "waitUntil",
+  "expect.poll",
+  "retryTimes",
+  "retry:",
+  "fetch(",
+  "WebSocket",
+  "XMLHttpRequest",
+  "navigator",
+  "Atomics",
+  "WeakRef",
+  "FinalizationRegistry",
+  "eval(",
+  "Function("
+];
+var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])|\bimport\.meta\.glob\b/;
+var COMPUTED = "loads a module whose name is computed";
+var RUNNER_PACKAGES = ["vitest", "@jest/globals"];
+function reachesOutside(file, trusted) {
+  const dense = file.source.replace(/\s/g, "");
+  const mark = REACHES.find((text) => dense.includes(text));
+  if (mark !== void 0) {
+    return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
+  }
+  if (COMPUTED_LOAD.test(dense)) {
+    return COMPUTED;
+  }
+  for (const { specifier, builtin } of file.imports) {
+    if (builtin) {
+      return `imports ${specifier}`;
+    } else if (![...RUNNER_PACKAGES, ...trusted].some(
+      (name) => specifier === name || specifier.startsWith(`${name}/`)
+    )) {
+      return `imports the package ${specifier}, which is not looked into`;
+    }
+  }
+  return null;
 }
-function runMutationResult(dir, reportOverride, io2) {
-  const manifest = readManifest(dir);
-  const reportPath = reportPathOf(manifest, reportOverride);
-  const shown = path5.relative(manifest.dir, reportPath) || reportPath;
-  let report;
-  try {
-    report = JSON.parse(fs5.readFileSync(reportPath, "utf8"));
-  } catch (error) {
-    io2.err(
-      `test-gates mutation: cannot read the Stryker JSON report ${shown} (${error.message}). Did Stryker finish, with the "json" reporter writing to this path?`
-    );
-    return 1;
+function jobsRefused(input) {
+  if (input.failurePattern) {
+    return "with settings.selfcheck.failurePattern, a run that was disturbed cannot be told from one that was not";
   }
-  if (typeof report !== "object" || report === null) {
-    io2.err(`test-gates mutation: ${shown} is not a Stryker JSON report`);
-    return 1;
+  if ("stray" in input.command) {
+    return `the gate command is not known to keep runs at the same time apart: only jest or "vitest run" with --config and options for the number of workers is (found: ${input.command.stray})`;
   }
-  const verdict = judgeMutationReport({
-    gates: manifest.gates,
-    report,
-    maxTimeouts: manifest.settings.maxTimeouts,
-    readSource: (gatePath) => {
-      try {
-        return fs5.readFileSync(path5.join(manifest.dir, gatePath), "utf8");
-      } catch {
-        return void 0;
+  const helper = input.command.runner === "jest" ? "createJestGatesConfig" : "createVitestGatesConfig";
+  if (input.configSource === null || !input.configSource.includes(helper)) {
+    return `the gate config does not use ${helper}`;
+  }
+  return null;
+}
+function jobsPlan(input) {
+  const byPath = new Map(input.files.map((file) => [file.path, file]));
+  const causes = input.roots.flatMap((root) => {
+    const loaded = root.files.flatMap((name) => {
+      const file = byPath.get(name);
+      return file === void 0 ? [] : [file];
+    });
+    let computed = false;
+    const reaches = loaded.flatMap((file) => {
+      const reach = reachesOutside(file, input.trusted);
+      const said = reach === null ? [] : [`${file.path} ${reach}`];
+      if (!COMPUTED_LOAD.test(file.source.replace(/\s/g, ""))) {
+        return said;
       }
+      computed = true;
+      return reach === COMPUTED ? said : [...said, `${file.path} ${COMPUTED}`];
+    });
+    const reasons = [
+      ...root.lost === null ? [] : [`${root.lost} cannot be followed`],
+      ...reaches
+    ];
+    if (reasons.length === 0) {
+      return [];
     }
+    const any = root.spec === null || root.lost !== null || computed;
+    const gates = input.gates.filter(
+      (gate) => gate.spec !== root.spec && (any || root.files.includes(withoutDots(gate.path)))
+    ).map((gate) => gate.path);
+    const by = root.spec === null ? "run with what the gate config names" : `${any ? "maybe loaded" : "loaded"} by ${root.spec}`;
+    return gates.length === 0 ? [] : [{ gates, reason: `${by}, in which ${reasons.join("; ")}` }];
   });
-  const summary = formatSummary(verdict.summary);
-  if (verdict.violations.length === 0 && verdict.survivors.length === 0) {
-    io2.out(`test-gates mutation: OK (${summary})`);
-    return 0;
+  const kept = new Set(causes.flatMap((cause) => cause.gates));
+  const paths = input.gates.map((gate) => gate.path);
+  return {
+    atOnce: paths.filter((gate) => !kept.has(gate)),
+    alone: paths.filter((gate) => kept.has(gate)),
+    causes
+  };
+}
+var TROUBLE = [
+  "fail",
+  "fails",
+  "failed",
+  "failing",
+  "failure",
+  "failures",
+  "err",
+  "timeout",
+  "timeouts",
+  "timed",
+  "unhandled",
+  "uncaught",
+  "killed",
+  "terminated",
+  "crashed",
+  "aborted",
+  "skipped",
+  "todo",
+  "retry",
+  "retried",
+  "obsolete",
+  "sigkill",
+  "sigterm",
+  "sigabrt",
+  "sigsegv",
+  "sigint"
+];
+var TROUBLE_SIGNS = ["\u2717", "\xD7", "\u2715", "\u2716"];
+function troubled(line) {
+  const words = line.toLowerCase().split(/[^a-z]/);
+  return (
+    // (`TypeError`, `errors`)
+    words.some((word) => TROUBLE.includes(word) || /errors?$/.test(word)) || TROUBLE_SIGNS.some((sign) => line.includes(sign))
+  );
+}
+function plain(line) {
+  return line.split("\x1B[").map((part, index) => index === 0 ? part : part.slice(part.indexOf("m") + 1)).join("").trim();
+}
+var SUMMARY = {
+  jest: {
+    files: "Test Suites:",
+    tests: "Tests:",
+    all: (count) => `${count} passed, ${count} total`
+  },
+  vitest: { files: "Test Files", tests: "Tests", all: (count) => `${count} passed (${count})` }
+};
+function cleanHold(input) {
+  const { output, gatePath, others } = input;
+  if (!input.held || input.signal !== null) {
+    return false;
   }
-  if (verdict.survivors.length > 0) {
-    io2.err(
-      `test-gates mutation: ${verdict.survivors.length} surviving mutant(s) not in the allow list`
-    );
-    for (const survivor of verdict.survivors) {
-      io2.err(`  - ${formatSurvivor(survivor)}`);
-    }
-    io2.err("");
-    io2.err(
-      "Fix the test so that it detects the mutant. Only when the mutant cannot be observed from"
-    );
-    io2.err("outside (same return value, exception and side effects for every input), add it to");
-    io2.err('"equivalentMutants" of the gate in test-gates.json and fill in "reason":');
-    const byFile = /* @__PURE__ */ new Map();
-    for (const survivor of verdict.survivors) {
-      byFile.set(survivor.file, [...byFile.get(survivor.file) ?? [], survivor]);
-    }
-    for (const [file, survivors] of byFile) {
-      io2.err("");
-      io2.err(`  ${file}`);
-      survivors.forEach((survivor, index) => {
-        const comma = index === survivors.length - 1 ? "" : ",";
-        io2.err(`    ${JSON.stringify(survivor.allowance)}${comma}`);
-      });
-    }
-    io2.err("");
+  const lines = output.split("\n").map(plain);
+  const summary = SUMMARY[input.runner];
+  const after = (label) => lines.filter((line) => line.startsWith(label)).map((line) => line.slice(label.length).trim());
+  const files = after(summary.files);
+  const tests = after(summary.tests);
+  const count = (tests[0] ?? "").split(" ")[0];
+  if (files.length !== 1 || files[0] !== summary.all(String(input.specs)) || tests.length !== 1 || !/^\d+$/.test(count) || tests[0] !== summary.all(count)) {
+    return false;
   }
-  const maxTimeouts = manifest.settings.maxTimeouts;
-  if (verdict.unexpectedTimeouts.length > maxTimeouts) {
-    io2.err(
-      `test-gates mutation: ${verdict.unexpectedTimeouts.length} mutant(s) timed out (settings.mutation.maxTimeouts: ${maxTimeouts})`
-    );
-    for (const mutant of verdict.unexpectedTimeouts) {
-      io2.err(`  - ${formatSurvivor(mutant)}`);
-    }
-    io2.err("");
-    io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
-    io2.err("can time out instead. Run again with less load (-- --concurrency 1). Only for a");
-    io2.err("mutant that can never finish (a loop that no longer ends), add it to");
-    io2.err('"expectedTimeouts" of the gate in test-gates.json and fill in "reason"');
-    io2.err("(settings.mutation.maxTimeouts raises the limit for the whole project):");
-    for (const mutant of verdict.unexpectedTimeouts) {
-      io2.err(`    ${mutant.file}: ${JSON.stringify(mutant.allowance)}`);
+  return lines.every((line) => {
+    const lower = line.toLowerCase();
+    if (lower.includes("threshold") || lower.includes("coverage data for")) {
+      return line.includes(gatePath) && !others.some((other) => line.includes(other));
     }
-    io2.err("");
-  }
-  if (verdict.violations.length > 0) {
-    printViolations(io2, "mutation", verdict.violations);
-  }
-  io2.err(`test-gates mutation: FAILED (${summary})`);
-  return 1;
+    return line.split("|").length >= 5 || // What stands around the names of the project, piece by piece.
+    !input.names.reduce((pieces, name) => pieces.flatMap((piece) => piece.split(name)), [line]).some(troubled);
+  });
 }
 
-// src/commands/mutation.ts
-function runMutation(dir, strykerArgs, io2) {
-  const manifest = readManifest(dir);
-  const config = findStrykerConfig(manifest);
-  if (config === null) {
-    throw new ManifestError(
-      "no Stryker config found (stryker.gates.config.mjs). Create one, or set settings.stryker.configFile"
-    );
-  }
-  const stryker = findLocalBin(manifest.dir, "stryker");
-  if (stryker === null) {
-    throw new ManifestError(
-      "stryker is not installed in this project (node_modules/.bin/stryker). Add @stryker-mutator/core as a devDependency"
-    );
+// src/touch.ts
+import { createHash as createHash2 } from "crypto";
+import fs11 from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countersOf(coverage) {
+  return {
+    s: Object.values(coverage.s ?? {}),
+    f: Object.values(coverage.f ?? {}),
+    b: Object.values(coverage.b ?? {}).flat()
+  };
+}
+function countersOfAll(coverage) {
+  if (!isObject(coverage)) {
+    return null;
   }
-  fs6.rmSync(reportPathOf(manifest, null), { force: true });
-  const result = spawnSync(stryker, ["run", config, ...strykerArgs], {
-    cwd: manifest.dir,
-    stdio: "inherit",
-    shell: process.platform === "win32"
-  });
-  if (result.error) {
-    io2.err(`test-gates mutation: cannot start Stryker (${result.error.message})`);
-    return 1;
+  const files = {};
+  for (const [file, counters] of Object.entries(coverage)) {
+    if (!isObject(counters)) {
+      return null;
+    }
+    files[file] = countersOf(counters);
   }
-  if (result.status !== 0) {
-    io2.err(
-      `test-gates mutation: Stryker failed (${result.signal ? `signal ${result.signal}` : `exit ${result.status}`}). The result was not judged`
-    );
-    return 1;
+  return files;
+}
+function isCounters(value) {
+  return isObject(value) && ["s", "f", "b"].every(
+    (key) => Array.isArray(value[key]) && value[key].every((count) => typeof count === "number")
+  );
+}
+function readNotes(directory) {
+  const read2 = (file) => {
+    try {
+      return JSON.parse(fs11.readFileSync(path11.join(directory, file), "utf8"));
+    } catch {
+      return null;
+    }
+  };
+  const run = read2("run.json");
+  let notes = [];
+  try {
+    for (const name of fs11.readdirSync(path11.join(directory, "specs"))) {
+      const note = read2(path11.join("specs", name));
+      if (!isObject(note) || typeof note.spec !== "string" || !isObject(note.files) || !Object.values(note.files).every(isCounters)) {
+        throw new Error("not a note");
+      }
+      notes.push(note);
+    }
+  } catch {
+    notes = null;
   }
-  return runMutationResult(dir, null, io2);
+  return {
+    run: isObject(run) && typeof run.runner === "string" && typeof run.version === "string" && typeof run.provider === "string" && typeof run.pool === "string" && typeof run.isolate === "boolean" && typeof run.projects === "number" && (run.problem === null || typeof run.problem === "string") ? run : null,
+    notes,
+    totals: countersOfAll(read2(path11.join("coverage", "coverage-final.json")))
+  };
 }
 
 // src/commands/selfcheck.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import fs7 from "fs";
-import path6 from "path";
 var JEST_CONFIGS = ["js", "cjs", "mjs", "ts", "cts", "mts"].map(
   (extension) => `jest.gates.config.${extension}`
 );
@@ -1690,7 +4033,7 @@ function resolveGateCommand(manifest) {
   if (manifest.settings.gateCommand !== null) {
     return manifest.settings.gateCommand;
   }
-  const exists = (name) => fs7.existsSync(path6.join(manifest.dir, name));
+  const exists = (name) => fs12.existsSync(path12.join(manifest.dir, name));
   const jest = JEST_CONFIGS.find(exists);
   const vitest = VITEST_CONFIGS.find(exists);
   if (jest && vitest) {
@@ -1708,16 +4051,271 @@ function resolveGateCommand(manifest) {
     "no gate config found (jest.gates.config.* / vitest.gates.config.*). Set settings.gateCommand"
   );
 }
-function runSelfcheck(dir, mode, commandOverride, io2) {
+var TOUCH_PREFIX = ".test-gates-touch-";
+function realPath(file) {
+  try {
+    return fs12.realpathSync(file);
+  } catch {
+    return file;
+  }
+}
+function shareOneRun(manifest, targets, runGate) {
+  let touchDir;
+  try {
+    for (const name of fs12.readdirSync(manifest.dir)) {
+      const left = path12.join(manifest.dir, name);
+      if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
+        fs12.rmSync(left, { recursive: true, force: true });
+      }
+    }
+    touchDir = fs12.mkdtempSync(path12.join(manifest.dir, TOUCH_PREFIX));
+  } catch {
+    return { reason: "the subproject cannot be written to" };
+  }
+  let plan;
+  try {
+    const recorded = runGate({ touchDir });
+    if (recorded.status !== 0) {
+      return { reason: "the gate run with every spec does not pass" };
+    }
+    const base = realPath(manifest.dir);
+    const absolute = (file) => realPath(path12.resolve(base, file));
+    const rekeyed = (files) => Object.fromEntries(Object.entries(files).map(([file, value]) => [absolute(file), value]));
+    const left = readNotes(touchDir);
+    plan = planControls({
+      all: manifest.gates.map((gate) => ({
+        path: gate.path,
+        file: path12.join(base, gate.path),
+        specFile: path12.join(base, gate.spec ?? "")
+      })),
+      targets: targets.map((gate) => gate.path),
+      run: left.run,
+      notes: left.notes?.map((note) => ({ spec: absolute(note.spec), files: rekeyed(note.files) })) ?? null,
+      totals: left.totals === null ? null : rekeyed(left.totals),
+      failurePattern: manifest.settings.selfcheckFailurePattern
+    });
+  } finally {
+    fs12.rmSync(touchDir, { recursive: true, force: true });
+  }
+  if (plan.reason !== null) {
+    return { reason: plan.reason };
+  }
+  const together = plan.together;
+  const gates = targets.filter((gate) => together.includes(gate.path));
+  return { gates, result: runGate({ excludeAll: gates.map((gate) => gate.spec) }) };
+}
+function installedVersion2(start, name) {
+  let current = path12.resolve(start);
+  for (; ; ) {
+    try {
+      const manifest = JSON.parse(
+        fs12.readFileSync(path12.join(current, "node_modules", name, "package.json"), "utf8")
+      );
+      return typeof manifest.version === "string" ? manifest.version : null;
+    } catch {
+      const parent = path12.dirname(current);
+      if (parent === current) {
+        return null;
+      }
+      current = parent;
+    }
+  }
+}
+function gateConfigFile(args) {
+  const joined = args.find((arg) => arg.startsWith("--config="));
+  const position = args.findIndex((arg) => arg === "--config" || arg === "-c");
+  return joined?.slice("--config=".length) ?? (position === -1 ? null : args[position + 1] ?? null);
+}
+function gateConfigSource(manifest, args) {
+  const file = gateConfigFile(args);
+  if (file === null) {
+    return null;
+  }
+  try {
+    return readText(manifest.dir, file);
+  } catch {
+    return null;
+  }
+}
+var JOBS_PREFIX = "test-gates-jobs-";
+async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
+  const results = /* @__PURE__ */ new Map();
+  let root;
+  try {
+    for (const name of fs12.readdirSync(os2.tmpdir())) {
+      const left = path12.join(os2.tmpdir(), name);
+      if (name.startsWith(JOBS_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
+        fs12.rmSync(left, { recursive: true, force: true });
+      }
+    }
+    root = fs12.realpathSync(fs12.mkdtempSync(path12.join(os2.tmpdir(), JOBS_PREFIX)));
+  } catch {
+    return results;
+  }
+  const queue = [...gates];
+  const line = async (dir) => {
+    for (let gate = queue.shift(); gate !== void 0; gate = queue.shift()) {
+      const spec = gate.spec;
+      results.set(
+        gate,
+        await new Promise((resolve) => {
+          const child = spawn(executable, [...args, ...jobFlags(runner, dir)], {
+            cwd: manifest.dir,
+            env: { ...process.env, [EXCLUDE_ENV]: spec, [EXCLUDE_ALL_ENV]: "", [TOUCH_ENV]: "" },
+            shell: process.platform === "win32"
+          });
+          let stdout = "";
+          let stderr = "";
+          child.stdout.on("data", (chunk) => stdout += chunk.toString());
+          child.stderr.on("data", (chunk) => stderr += chunk.toString());
+          child.stdin.on("error", () => void 0);
+          child.stdin.end();
+          child.on("error", () => resolve({ status: null, signal: null, stdout, stderr }));
+          child.on("close", (status, signal) => resolve({ status, signal, stdout, stderr }));
+        })
+      );
+    }
+  };
+  try {
+    await Promise.all(
+      Array.from(
+        { length: Math.min(jobs, gates.length) },
+        (_unused, index) => line(path12.join(root, `line-${index}`))
+      )
+    );
+  } finally {
+    fs12.rmSync(root, { recursive: true, force: true });
+  }
+  return results;
+}
+async function runSelfcheck(dir, selection, commandOverride, io2) {
+  const refused = selection.quick === true ? quickRefused(process.env) : null;
+  if (refused !== null) {
+    throw new UsageError(refused);
+  }
   const manifest = readManifest(dir);
   if (manifest.violations.length > 0 || manifest.gates.length === 0) {
     io2.err('test-gates selfcheck: test-gates.json has problems. Run "test-gates check" first');
     return 1;
   }
+  const chosen = selectControls({
+    gates: manifest.gates.map((gate) => gate.path),
+    mode: selection.mode ?? manifest.settings.selfcheckMode,
+    only: selection.gates,
+    shard: selection.shard
+  });
+  if ("error" in chosen) {
+    throw new UsageError(chosen.error);
+  }
+  const targets = manifest.gates.filter((gate) => chosen.selected.includes(gate.path));
+  const skipped = manifest.gates.length - targets.length;
+  const notSelected = selection.shard !== null ? `, ${skipped} gate(s) not selected by --shard ${selection.shard.index}/${selection.shard.total}` : selection.gates.length > 0 ? `, ${skipped} gate(s) not selected by --gate` : "";
   const command = commandOverride.length > 0 ? commandOverride : resolveGateCommand(manifest);
   const [program, ...args] = command;
   const executable = findLocalBin(manifest.dir, program) ?? program;
-  const targets = (mode ?? manifest.settings.selfcheckMode) === "first" ? manifest.gates.slice(0, 1) : manifest.gates;
+  const runGate = (env) => spawnSync4(executable, args, {
+    cwd: manifest.dir,
+    env: {
+      ...process.env,
+      [EXCLUDE_ENV]: env.exclude ?? "",
+      [EXCLUDE_ALL_ENV]: env.excludeAll === void 0 ? "" : JSON.stringify(env.excludeAll),
+      [TOUCH_ENV]: env.touchDir ?? ""
+    },
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024,
+    shell: process.platform === "win32"
+  });
+  const judge = (result, gatePath) => result.error ? `cannot start "${command.join(" ")}" (${result.error.message})` : judgeSelfcheck({
+    status: result.status,
+    output: `${result.stdout ?? ""}${result.stderr ?? ""}`,
+    gatePath,
+    failurePattern: manifest.settings.selfcheckFailurePattern
+  });
+  const heldTogether = /* @__PURE__ */ new Map();
+  const single = targets.filter((gate) => gate.spec !== null && gate.existingSpecs.length === 1);
+  if (selection.quick === true && single.length >= 3) {
+    const configSource = gateConfigSource(manifest, args);
+    const shared = sharedRunPrecheck({
+      program,
+      version: installedVersion2(manifest.dir, program),
+      configSource,
+      specs: manifest.gates.flatMap(
+        (gate) => gate.existingSpecs.map((spec) => ({ path: spec, source: readText(manifest.dir, spec) }))
+      )
+    }) ?? shareOneRun(manifest, single, runGate);
+    if (typeof shared === "string" || "reason" in shared) {
+      const reason = typeof shared === "string" ? shared : shared.reason;
+      io2.out(`test-gates selfcheck: a run of the gate command for every gate (${reason})`);
+    } else {
+      for (const gate of shared.gates) {
+        if (judge(shared.result, gate.path) === null) {
+          heldTogether.set(gate.path, shared.result.status);
+        }
+      }
+    }
+  }
+  const heldAtOnce = /* @__PURE__ */ new Map();
+  const waiting = single.filter((gate) => !heldTogether.has(gate.path));
+  const jobs = selection.jobs ?? 1;
+  if (jobs > 1 && waiting.length > 1) {
+    const known = knownCommand(program, args);
+    const refusal = jobsRefused({
+      failurePattern: manifest.settings.selfcheckFailurePattern,
+      command: known,
+      configSource: gateConfigSource(manifest, args)
+    });
+    if (refusal !== null || !("runner" in known)) {
+      io2.out(`test-gates selfcheck: one negative control at a time (${refusal})`);
+    } else {
+      const plan = jobsPlan({
+        gates: waiting.map((gate) => ({ path: gate.path, spec: gate.spec })),
+        ...loadedFiles(manifest, gateConfigFile(args)),
+        trusted: manifest.settings.importMode === "allowlist" ? manifest.settings.importAllow.flatMap(
+          (rule) => rule.module === void 0 ? [] : [rule.module]
+        ) : []
+      });
+      if (plan.alone.length > 0) {
+        io2.out(
+          `test-gates selfcheck: ${plan.alone.length} of ${waiting.length} negative control(s) run one at a time, since in their runs something that loads the gate also loads a file that may meet what another run is doing:`
+        );
+        for (const { gates, reason } of plan.causes) {
+          io2.out(`  ${gates.join(", ")}: ${reason}`);
+        }
+      }
+      const atOnce = waiting.filter((gate) => plan.atOnce.includes(gate.path));
+      if (atOnce.length > 1) {
+        const specs = new Set(manifest.gates.map((gate) => gate.spec)).size - 1;
+        const names = [
+          manifest.dir,
+          realPath(manifest.dir),
+          ...manifest.gates.flatMap((gate) => [gate.path, gate.spec])
+        ].sort((left, right) => right.length - left.length);
+        const results = await runAtOnce(manifest, atOnce, jobs, known.runner, executable, args);
+        for (const [gate, result] of results) {
+          const output = `${result.stdout}${result.stderr}`;
+          const clean = cleanHold({
+            held: judgeSelfcheck({ status: result.status, output, gatePath: gate.path }) === null,
+            signal: result.signal,
+            output,
+            runner: known.runner,
+            specs,
+            gatePath: gate.path,
+            others: manifest.gates.map((other) => other.path).filter((other) => other !== gate.path),
+            names
+          });
+          if (clean) {
+            heldAtOnce.set(gate.path, result.status);
+          }
+        }
+        const again = atOnce.length - heldAtOnce.size;
+        if (again > 0) {
+          io2.out(
+            `test-gates selfcheck: ${again} of ${atOnce.length} negative control(s) did not hold cleanly next to others and run again on their own`
+          );
+        }
+      }
+    }
+  }
   let failed = 0;
   for (const gate of targets) {
     if (gate.spec === null || gate.existingSpecs.length !== 1) {
@@ -1725,20 +4323,19 @@ function runSelfcheck(dir, mode, commandOverride, io2) {
       failed += 1;
       continue;
     }
-    const result = spawnSync2(executable, args, {
-      cwd: manifest.dir,
-      env: { ...process.env, [EXCLUDE_ENV]: gate.spec },
-      encoding: "utf8",
-      maxBuffer: 256 * 1024 * 1024,
-      shell: process.platform === "win32"
-    });
+    if (heldTogether.has(gate.path)) {
+      io2.out(
+        `  \u2713 without ${gate.spec} the gate fails (exit ${heldTogether.get(gate.path)}, in the shared run)`
+      );
+      continue;
+    }
+    if (heldAtOnce.has(gate.path)) {
+      io2.out(`  \u2713 without ${gate.spec} the gate fails (exit ${heldAtOnce.get(gate.path)})`);
+      continue;
+    }
+    const result = runGate({ exclude: gate.spec });
     const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const reason = result.error ? `cannot start "${command.join(" ")}" (${result.error.message})` : judgeSelfcheck({
-      status: result.status,
-      output,
-      gatePath: gate.path,
-      failurePattern: manifest.settings.selfcheckFailurePattern
-    });
+    const reason = judge(result, gate.path);
     if (reason === null) {
       io2.out(`  \u2713 without ${gate.spec} the gate fails (exit ${result.status})`);
     } else {
@@ -1763,10 +4360,14 @@ function runSelfcheck(dir, mode, commandOverride, io2) {
     }
   }
   if (failed > 0) {
-    io2.err(`test-gates selfcheck: FAILED (${failed} of ${targets.length} negative control(s))`);
+    io2.err(
+      `test-gates selfcheck: FAILED (${failed} of ${targets.length} negative control(s)${notSelected})${quickCaveat(heldTogether.size)}`
+    );
     return 1;
   }
-  io2.out(`test-gates selfcheck: OK (${targets.length} negative control(s) failed as they should)`);
+  io2.out(
+    `test-gates selfcheck: OK (${targets.length} negative control(s) failed as they should${notSelected})${quickCaveat(heldTogether.size)}`
+  );
   return 0;
 }
 
@@ -1781,12 +4382,26 @@ Commands:
                               Unknown arguments and everything after "--" go to Stryker
   mutation-result             Judge an existing Stryker JSON report
   selfcheck [-- <command>]    Negative control: leave one spec out, the gate must fail
-  lcov --file <lcov.info>     Per-file 100% line coverage from an lcov tracefile
+  lcov [--file <lcov.info>]   Per-file 100% line coverage from an lcov tracefile
+  doctor                      Why a mutation run would not reuse the last results, and what
+                              to change. Runs nothing; exit 1 when runs are full ones needlessly
 
 Options:
   --dir <subproject>          Directory that holds test-gates.json (default: .)
   --report <path>             mutation-result: report to judge (default: settings.stryker.reportFile)
   --all | --first             selfcheck: every gate in turn (default) or only the first
+  --gate <path>               selfcheck: only this gate (may be given more than once).
+                              mutation: only the mutants of this gate, while working on it.
+                              Not the final check, and refused when CI is set
+  --affected                  mutation: run again only the gates that a change since the last
+                              run can affect, and reuse the results of the others. Every
+                              mutant is run when CI is set
+  --shard <index>/<total>     selfcheck: one of <total> parts of the gates, for parallel CI jobs
+  --jobs <n>                  selfcheck: run <n> negative controls at the same time. One that does
+                              not hold cleanly there is run again on its own
+  --quick                     selfcheck: one run for the gates only their own spec touches.
+                              Not the final check: it assumes that no spec depends on which
+                              other specs run. Refused when CI is set
   --file <path>               lcov: tracefile (default: settings.lcov.file)
   -h, --help                  Show this help
   -v, --version               Show the version
@@ -1802,7 +4417,7 @@ var io = {
 function main(argv) {
   const args = parseArgs(argv);
   if (args.version) {
-    const { version } = createRequire(import.meta.url)("../package.json");
+    const { version } = createRequire2(import.meta.url)("../package.json");
     io.out(version);
     return 0;
   }
@@ -1813,12 +4428,25 @@ function main(argv) {
   switch (args.command) {
     case "check":
       return runCheck(args.dir, io);
+    case "doctor":
+      return runDoctor(args.dir, io);
     case "mutation":
-      return runMutation(args.dir, args.rest, io);
+      return runMutation(args.dir, args.rest, io, args.gates, args.affected);
     case "mutation-result":
       return runMutationResult(args.dir, args.report, io);
     case "selfcheck":
-      return runSelfcheck(args.dir, args.mode, args.rest, io);
+      return runSelfcheck(
+        args.dir,
+        {
+          mode: args.mode,
+          gates: args.gates,
+          shard: args.shard,
+          quick: args.quick,
+          jobs: args.jobs
+        },
+        args.rest,
+        io
+      );
     case "lcov":
       return runLcov(args.dir, args.file, io);
     case null:
@@ -1826,7 +4454,7 @@ function main(argv) {
   }
 }
 try {
-  process.exitCode = main(process.argv.slice(2));
+  process.exitCode = await main(process.argv.slice(2));
 } catch (error) {
   if (error instanceof UsageError) {
     io.err(`test-gates: ${error.message}