@t09tanaka/test-gates 0.3.4 → 0.4.1

package/dist/cli.js

@@ -4,7 +4,14 @@
 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", "--gate", "--shard", "--jobs"];
@@ -21,10 +28,11 @@ function parseShard(value) {
 }
 var OPTIONS_BY_COMMAND = {
   check: ["--dir"],
-  mutation: ["--dir", "--gate"],
+  mutation: ["--dir", "--gate", "--affected"],
   "mutation-result": ["--dir", "--report"],
   selfcheck: ["--dir", "--all", "--first", "--gate", "--shard", "--quick", "--jobs"],
-  lcov: ["--dir", "--file"]
+  lcov: ["--dir", "--file"],
+  doctor: ["--dir"]
 };
 function consume(parsed, argv, index, allowed) {
   const arg = argv[index];
@@ -77,6 +85,10 @@ function consume(parsed, argv, index, allowed) {
       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");
@@ -104,6 +116,7 @@ function parseArgs(argv) {
     gates: [],
     shard: null,
     quick: false,
+    affected: false,
     jobs: null,
     rest: []
   };
@@ -128,14 +141,22 @@ function parseArgs(argv) {
   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 "--"`
     );
   }
-  if (parsed.rest.some((arg) => arg === "--gate" || arg.startsWith("--gate="))) {
-    throw new UsageError('--gate after "--" would go to Stryker. 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');
@@ -1003,13 +1024,13 @@ function judgeSelfcheck(input) {
 function selectControls(input) {
   const { gates, mode, only, shard } = input;
   if (only.length > 0) {
-    const unknown = only.filter((path11) => !gates.includes(path11));
+    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((path11) => only.includes(path11)) };
+    return { selected: gates.filter((path13) => only.includes(path13)) };
   }
   if (shard !== null) {
     if (shard.total > gates.length) {
@@ -1049,6 +1070,9 @@ function quickRefused(env) {
 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`;
 }
@@ -1384,179 +1408,34 @@ 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);
-    }
-  }
-  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 path11 = normalizePath(line.slice(3), rootDir);
-      const file = files.get(path11) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
-      files.set(path11, 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(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 });
-      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/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");
 }
-
-// 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 = 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`
-    );
-    return 1;
+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 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`);
+  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 };
   }
-  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/mutation.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import fs7 from "fs";
-import path7 from "path";
-import { pathToFileURL } from "url";
-
-// src/core/reuse-guard.ts
-var RECORD_FORMAT = 1;
-function isStringRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+  return { tests, gates: parsed };
 }
 function parseRecord(value) {
-  const { format, incremental, snapshot } = value ?? {};
+  const { format, incremental, snapshot, affected } = value ?? {};
   if (format !== RECORD_FORMAT || typeof incremental !== "string") {
     return null;
   }
@@ -1567,13 +1446,18 @@ function parseRecord(value) {
   if (mode !== "git" && mode !== "walk") {
     return null;
   }
-  if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
+  if (!isStringList(args) || !isStringRecord(environment) || !isStringRecord(files)) {
     return null;
   }
-  if (!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.affected = parsed;
   }
-  return { format, incremental, snapshot: { mode, environment, args, files } };
+  return record;
 }
 function listed(names) {
   const shown = names.slice(0, 3).join(", ");
@@ -1582,33 +1466,42 @@ function listed(names) {
 function differingKeys(before, after) {
   return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((key) => before[key] !== after[key]).sort();
 }
-function refuseReuse(input) {
+function readRecord(input) {
   if (input.record === void 0) {
-    return "there is no record of the run that wrote the incremental file";
+    return { refused: "there is no record of the run that wrote the incremental file" };
   }
   const record = parseRecord(input.record);
   if (record === null) {
-    return "the record of the last run is not one this version can read";
+    return { refused: "the record of the last run is not one this version can read" };
   }
   if (record.incremental !== input.incremental) {
-    return "the incremental file is not the one the last recorded run wrote";
+    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 `the files are listed in another way than in the last run (${before.mode}, now ${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 `the tools changed since the last run: ${listed(changes)}`;
+    return { refused: `the tools changed since the last run: ${listed(changes)}` };
   }
   if (JSON.stringify(before.args) !== JSON.stringify(now.args)) {
-    return "the arguments for Stryker are not those of the last run";
+    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(before.files, now.files);
+  const files = differingKeys(read2.record.snapshot.files, input.snapshot.files);
   if (files.length > 0) {
     return `changed since the last run: ${listed(files)}`;
   }
@@ -1639,6 +1532,239 @@ 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);
+      }
+    }
+    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 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 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);
+    }
+  }
+  return { rerun, reused };
+}
+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;
+    }
+    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 [...new Set(ranges)];
+}
+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 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)}`
+    );
+  }
+  if (plan.rerun.length > shown) {
+    lines.push(`  and ${plan.rerun.length - shown} more`);
+  }
+  if (timeouts > 0) {
+    lines.push(`  and ${timeouts} mutant(s) of reused gates that timed out in the last run`);
+  }
+  return lines;
+}
+
+// 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.blind !== null) {
+    findings.push({
+      level: facts.hooks.some((hook) => hook.affected) ? "problem" : "note",
+      text: `with --affected, a change of any file runs every mutant: what a gate depends on cannot be told (${facts.blind})`,
+      fix: "keep what reads files or loads modules by a computed name out of what the gates and their specs import, or run without --affected"
+    });
+  }
+  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 && facts.blind === null)) {
+    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/snapshot.ts
 import { spawnSync } from "child_process";
 import { createHash } from "crypto";
@@ -1646,17 +1772,167 @@ import fs5 from "fs";
 import { createRequire } from "module";
 import os from "os";
 import path5 from "path";
-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",
+
+// 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 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 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 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",
@@ -1678,8 +1954,14 @@ var LOCK_FILES = [
   "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");
 }
@@ -1697,8 +1979,21 @@ function isInside(parent, child) {
 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;
+  }
+  const rest = { ...env };
+  delete rest.GIT_DIR;
+  return rest;
+}
 function git(cwd, args) {
-  const result = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 * 1024 });
+  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 gitLister(root) {
@@ -1831,7 +2126,7 @@ function ownVersion() {
   const { version } = createRequire(import.meta.url)("../package.json");
   return version;
 }
-function takeSnapshot(input) {
+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());
@@ -1845,6 +2140,7 @@ function takeSnapshot(input) {
   }
   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);
@@ -1860,34 +2156,75 @@ function takeSnapshot(input) {
   }
   const files = /* @__PURE__ */ Object.create(null);
   const regions = [dir];
+  const widened = [];
   const queued = new Set(regions);
-  const enqueue = (target, from) => {
-    const directory = isInside(target, dir) && isInside(listRoot, target) ? listRoot : target;
+  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 (${directory})`
+        `${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 = (literal, file) => {
-    const fixed = literal.includes("${") ? literal.slice(0, literal.lastIndexOf("/", literal.indexOf("${")) + 1) : literal;
-    if (!fixed.startsWith("../")) {
-      enqueue(listRoot, file);
-      return;
-    }
+  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);
+      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;
+      }
+      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) => {
@@ -1919,11 +2256,10 @@ function takeSnapshot(input) {
     } else {
       const content = fs5.readFileSync(file);
       files[relative] = hashOf(content);
-      if (content.length <= SCAN_LIMIT && !content.subarray(0, 8e3).includes(0)) {
-        const text = content.toString("utf8").replace(/\\[\\/]/g, "/");
-        for (const match of text.matchAll(UPWARD)) {
-          follow(match[2], file);
-        }
+      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);
       }
     }
   };
@@ -1965,17 +2301,477 @@ function takeSnapshot(input) {
       environment[name] = version;
     }
   }
-  return {
-    mode,
-    environment,
-    args: input.args,
-    files
-  };
+  return { snapshot: { mode, environment, args: input.args, files }, root: listRoot, widened };
 }
 
-// src/commands/mutation-result.ts
+// 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);
+        }
+      }
+    }
+  }
+  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);
+        }
+      }
+    }
+    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));
+        }
+      }
+    }
+  }
+  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
+    };
+  }
+  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);
+        }
+      }
+    }
+  }
+  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;
+        }
+      }
+    }
+  }
+  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.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import fs8 from "fs";
+import path8 from "path";
+import { pathToFileURL } from "url";
+
+// 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"]);
@@ -1984,7 +2780,7 @@ var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
 function normalizeCode(text) {
   return text.replace(/\s+/g, " ").trim();
 }
-function normalizePath2(file) {
+function normalizePath(file) {
   return file.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function normalizeNewlines(text) {
@@ -2050,10 +2846,10 @@ function judgeMutationReport(input) {
   };
   const files = /* @__PURE__ */ new Map();
   for (const [file, result] of Object.entries(input.report.files ?? {})) {
-    files.set(normalizePath2(file), result);
+    files.set(normalizePath(file), result);
   }
   for (const gate of input.gates) {
-    const gatePath = normalizePath2(gate.path);
+    const gatePath = normalizePath(gate.path);
     const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
     violations.push(...shapeViolations);
     violations.push(
@@ -2225,17 +3021,17 @@ function formatSummary(summary) {
 
 // src/commands/mutation-result.ts
 function reportPathOf(manifest, override) {
-  return path6.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+  return path7.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
 }
-function runMutationResult(dir, reportOverride, io2, only = []) {
+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 = path6.relative(manifest.dir, reportPath) || reportPath;
+  const shown = path7.relative(manifest.dir, reportPath) || reportPath;
   let report;
   try {
-    report = JSON.parse(fs6.readFileSync(reportPath, "utf8"));
+    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?`
@@ -2252,12 +3048,13 @@ function runMutationResult(dir, reportOverride, io2, only = []) {
     maxTimeouts: manifest.settings.maxTimeouts,
     readSource: (gatePath) => {
       try {
-        return fs6.readFileSync(path6.join(manifest.dir, gatePath), "utf8");
+        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}`);
@@ -2319,15 +3116,15 @@ function runMutationResult(dir, reportOverride, io2, only = []) {
 // src/commands/mutation.ts
 var CONFIG_MARK = "\0test-gates-stryker-config\0";
 function loadStrykerConfig(manifest, config) {
-  const file = path7.resolve(manifest.dir, config);
+  const file = path8.resolve(manifest.dir, config);
   if (file.endsWith(".json")) {
     try {
-      return JSON.parse(fs7.readFileSync(file, "utf8"));
+      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,}) + ${JSON.stringify(CONFIG_MARK)});`;
+  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",
@@ -2341,7 +3138,7 @@ function loadStrykerConfig(manifest, config) {
 }
 function modifiedAt(file) {
   try {
-    const stat = fs7.statSync(file, { bigint: true });
+    const stat = fs8.statSync(file, { bigint: true });
     return `${stat.mtimeNs} ${stat.ino}`;
   } catch {
     return null;
@@ -2350,145 +3147,643 @@ function modifiedAt(file) {
 function guardRecordPath(incrementalFile) {
   return `${incrementalFile}.test-gates.json`;
 }
-function guardIncremental(manifest, config, strykerArgs, part) {
-  const nothing = { force: null, record: () => void 0 };
+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,
+    unchanged: null,
+    configs
+  };
   if (loaded !== void 0 && !options.incremental) {
-    return nothing;
+    return decision;
   }
-  const base = fs7.realpathSync(manifest.dir);
-  const incrementalFile = path7.resolve(base, options.incrementalFile);
+  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 {
-      snapshot = takeSnapshot({
+      let widened;
+      ({ snapshot, root, widened } = snapshotOf({
+        scope,
         dir: manifest.dir,
         written: [
           incrementalFile,
           recordFile,
-          path7.resolve(base, options.tempDirName),
-          path7.resolve(base, manifest.settings.strykerReportFile)
+          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})`;
     }
   }
-  let force = null;
+  decision.snapshot = snapshot;
+  decision.failure = snapshot === null ? failure : null;
+  decision.root = root;
   const incremental = hashFile(incrementalFile);
+  decision.incrementalHash = incremental;
   if (part) {
-    fs7.rmSync(recordFile, { force: true });
-    return {
-      force: incremental !== null && !options.force ? "with --gate nothing is taken over from an earlier run" : null,
-      record: () => void 0
-    };
+    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 {
-      let record;
-      try {
-        record = JSON.parse(fs7.readFileSync(recordFile, "utf8"));
-      } catch {
-        record = void 0;
+      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) {
+          if (refuseReuse({ record: stored, incremental, snapshot }) === null) {
+            decision.unchanged = plan.full;
+            plan = null;
+          } else {
+            force = plan.full;
+          }
+        }
       }
-      force = refuseReuse({ record, incremental, snapshot });
     }
+  } 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 };
   }
-  fs7.rmSync(recordFile, { force: true });
+  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 (decision.unchanged !== null) {
+      said = [
+        `test-gates mutation --affected: nothing changed since the last run, every result is reused (gate by gate, ${decision.unchanged.replace(/^what a gate/, "what each gate")})`,
+        ...ranges.length > 0 ? [`  and ${ranges.length} mutant(s) that timed out in the last run are run again`] : []
+      ];
+    }
+  } 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 {
-    force,
-    record: () => {
+    // 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 {
-        fs7.writeFileSync(recordFile, `${JSON.stringify(record)}
+        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 if (affected.unchanged !== null) {
+      io2.out("  next run with --affected: reuses the results of the last run (nothing changed)");
+    } 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"}`);
+    }
+  }
+  let blind = null;
+  if (plain2.snapshot !== null) {
+    try {
+      affectedInputs(manifest, {
+        root: plain2.root,
+        files: plain2.snapshot.files,
+        configs: plain2.configs(),
+        tests: [],
+        covering: {}
+      });
+    } catch (error) {
+      if (!(error instanceof AffectedError)) {
+        throw error;
+      }
+      blind = error.message;
+    }
+  }
+  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)),
+      blind
+    })
+  );
+  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 runMutation(dir, strykerArgs, io2, only = []) {
-  const part = only.length > 0;
-  if (part) {
-    const refused = gateRunRefused(process.env);
-    if (refused !== null) {
-      throw new UsageError(refused);
+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 (strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
-      throw new UsageError("--gate and --mutate cannot be combined: --gate sets --mutate itself");
+    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 });
   }
-  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"
-    );
+  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;
   }
-  const stryker = findLocalBin(manifest.dir, "stryker");
-  if (stryker === null) {
+  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(
-      "stryker is not installed in this project (node_modules/.bin/stryker). Add @stryker-mutator/core as a devDependency"
+      "no lcov file given. Pass --file <lcov.info> or set settings.lcov.file"
     );
   }
-  const reportFile = reportPathOf(manifest, null);
-  fs7.rmSync(reportFile, { force: true });
-  const guard = guardIncremental(manifest, config, strykerArgs, part);
-  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 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 guardArgs = guard.force === null ? [] : ["--force"];
-  const partArgs = part ? ["--mutate", chosen.selected.join(",")] : [];
-  const result = spawnSync2(stryker, ["run", config, ...strykerArgs, ...partArgs, ...guardArgs], {
-    cwd: manifest.dir,
-    stdio: "inherit",
-    shell: process.platform === "win32"
+  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;
   });
-  if (result.error) {
-    io2.err(`test-gates mutation: cannot start Stryker (${result.error.message})`);
-    return 1;
+  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 (result.status !== 0) {
-    io2.err(
-      `test-gates mutation: Stryker failed (${result.signal ? `signal ${result.signal}` : `exit ${result.status}`}). The result was not judged`
-    );
+  violations.push(...verdict.violations);
+  if (violations.length > 0) {
+    printViolations(io2, "lcov", violations);
     return 1;
   }
-  guard.record();
-  const status = runMutationResult(dir, null, io2, part ? chosen.selected : []);
-  if (part) {
-    fs7.rmSync(reportFile, { force: true });
-  }
-  return status;
+  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 spawnSync3 } from "child_process";
-import fs10 from "fs";
+import { spawn, spawnSync as spawnSync4 } from "child_process";
+import fs12 from "fs";
 import os2 from "os";
-import path10 from "path";
+import path12 from "path";
 
 // src/core/jobs.ts
 var SWITCHES = {
@@ -2557,7 +3852,8 @@ var REACHES = [
   "eval(",
   "Function("
 ];
-var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])/;
+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, "");
@@ -2566,7 +3862,7 @@ function reachesOutside(file, trusted) {
     return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
   }
   if (COMPUTED_LOAD.test(dense)) {
-    return "loads a module whose name is computed";
+    return COMPUTED;
   }
   for (const { specifier, builtin } of file.imports) {
     if (builtin) {
@@ -2590,17 +3886,47 @@ function jobsRefused(input) {
   if (input.configSource === null || !input.configSource.includes(helper)) {
     return `the gate config does not use ${helper}`;
   }
-  if (input.lost !== null) {
-    return `${input.lost} cannot be followed, so what the gate run loads is not known`;
-  }
-  for (const file of input.files) {
-    const reach = reachesOutside(file, input.trusted);
-    if (reach !== null) {
-      return `${file.path} ${reach}, and may meet what another run is doing`;
-    }
-  }
   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 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",
@@ -2674,8 +4000,8 @@ function cleanHold(input) {
 
 // src/touch.ts
 import { createHash as createHash2 } from "crypto";
-import fs8 from "fs";
-import path8 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import { fileURLToPath } from "url";
 var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
 function isObject(value) {
@@ -2707,18 +4033,18 @@ function isCounters(value) {
   );
 }
 function readNotes(directory) {
-  const read = (file) => {
+  const read2 = (file) => {
     try {
-      return JSON.parse(fs8.readFileSync(path8.join(directory, file), "utf8"));
+      return JSON.parse(fs11.readFileSync(path11.join(directory, file), "utf8"));
     } catch {
       return null;
     }
   };
-  const run = read("run.json");
+  const run = read2("run.json");
   let notes = [];
   try {
-    for (const name of fs8.readdirSync(path8.join(directory, "specs"))) {
-      const note = read(path8.join("specs", name));
+    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");
       }
@@ -2730,135 +4056,8 @@ function readNotes(directory) {
   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(read(path8.join("coverage", "coverage-final.json")))
-  };
-}
-
-// src/commands/loaded-files.ts
-import fs9 from "fs";
-import { builtinModules } from "module";
-import path9 from "path";
-var SCRIPT = /\.[cm]?[jt]sx?$/;
-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 fs9.statSync(file).isFile();
-  } catch {
-    return false;
-  }
-}
-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) => path9.join(base, `index${extension}`)) : []
-  ];
-  return candidates.find(isFile) ?? null;
-}
-function installed(specifier, from) {
-  const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
-  for (let current = path9.dirname(from); ; current = path9.dirname(current)) {
-    if (fs9.existsSync(path9.join(current, "node_modules", name))) {
-      return true;
-    }
-    if (current === path9.dirname(current)) {
-      return false;
-    }
-  }
-}
-function loadedFiles(manifest, configFile) {
-  const aliases = manifest.settings.importAliases;
-  const relative = (file) => path9.relative(manifest.dir, file).split(path9.sep).join("/");
-  const target = (specifier, from) => {
-    if (specifier.startsWith(".")) {
-      return resolveFile(path9.resolve(path9.dirname(from), specifier));
-    }
-    const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
-    return alias === void 0 ? null : resolveFile(
-      path9.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
-    );
-  };
-  const read = (file) => {
-    const source = fs9.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 ? [] : [path9.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 } = read(file);
-    const paths = strings.filter((text) => file === entry || /^(?:\.|<rootDir>\/)/.test(text));
-    for (const text of paths) {
-      const stripped = text.replace(/^<rootDir>\//, "");
-      const found = resolveFile(path9.resolve(path9.dirname(file), stripped), false) ?? resolveFile(path9.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 queue = [
-    ...manifest.gates.flatMap(
-      (gate) => gate.existingSpecs.map((spec) => path9.join(manifest.dir, spec))
-    ),
-    ...named
-  ];
-  const seen = new Set(queue);
-  const follow = (found) => {
-    if (SCRIPT.test(found) && !seen.has(found)) {
-      seen.add(found);
-      queue.push(found);
-    }
+    totals: countersOfAll(read2(path11.join("coverage", "coverage-final.json")))
   };
-  const files = [];
-  let lost = null;
-  for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
-    const { source, specifiers, strings } = read(file);
-    const imports = [];
-    for (const specifier of specifiers) {
-      if (isProjectImport(specifier, aliases)) {
-        const found = target(specifier, file);
-        if (found === null) {
-          lost ??= `${specifier} (imported by ${relative(file)})`;
-        } else {
-          follow(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(path9.resolve(path9.dirname(file), text));
-      if (found !== null) {
-        follow(found);
-      }
-    }
-    files.push({ path: relative(file), source, imports });
-  }
-  return { files, lost };
 }
 
 // src/commands/selfcheck.ts
@@ -2872,7 +4071,7 @@ function resolveGateCommand(manifest) {
   if (manifest.settings.gateCommand !== null) {
     return manifest.settings.gateCommand;
   }
-  const exists = (name) => fs10.existsSync(path10.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) {
@@ -2893,7 +4092,7 @@ function resolveGateCommand(manifest) {
 var TOUCH_PREFIX = ".test-gates-touch-";
 function realPath(file) {
   try {
-    return fs10.realpathSync(file);
+    return fs12.realpathSync(file);
   } catch {
     return file;
   }
@@ -2901,13 +4100,13 @@ function realPath(file) {
 function shareOneRun(manifest, targets, runGate) {
   let touchDir;
   try {
-    for (const name of fs10.readdirSync(manifest.dir)) {
-      const left = path10.join(manifest.dir, name);
-      if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs10.statSync(left).mtimeMs > 36e5) {
-        fs10.rmSync(left, { recursive: true, force: true });
+    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 = fs10.mkdtempSync(path10.join(manifest.dir, TOUCH_PREFIX));
+    touchDir = fs12.mkdtempSync(path12.join(manifest.dir, TOUCH_PREFIX));
   } catch {
     return { reason: "the subproject cannot be written to" };
   }
@@ -2918,14 +4117,14 @@ function shareOneRun(manifest, targets, runGate) {
       return { reason: "the gate run with every spec does not pass" };
     }
     const base = realPath(manifest.dir);
-    const absolute = (file) => realPath(path10.resolve(base, file));
+    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: path10.join(base, gate.path),
-        specFile: path10.join(base, gate.spec ?? "")
+        file: path12.join(base, gate.path),
+        specFile: path12.join(base, gate.spec ?? "")
       })),
       targets: targets.map((gate) => gate.path),
       run: left.run,
@@ -2934,7 +4133,7 @@ function shareOneRun(manifest, targets, runGate) {
       failurePattern: manifest.settings.selfcheckFailurePattern
     });
   } finally {
-    fs10.rmSync(touchDir, { recursive: true, force: true });
+    fs12.rmSync(touchDir, { recursive: true, force: true });
   }
   if (plan.reason !== null) {
     return { reason: plan.reason };
@@ -2944,15 +4143,15 @@ function shareOneRun(manifest, targets, runGate) {
   return { gates, result: runGate({ excludeAll: gates.map((gate) => gate.spec) }) };
 }
 function installedVersion2(start, name) {
-  let current = path10.resolve(start);
+  let current = path12.resolve(start);
   for (; ; ) {
     try {
       const manifest = JSON.parse(
-        fs10.readFileSync(path10.join(current, "node_modules", name, "package.json"), "utf8")
+        fs12.readFileSync(path12.join(current, "node_modules", name, "package.json"), "utf8")
       );
       return typeof manifest.version === "string" ? manifest.version : null;
     } catch {
-      const parent = path10.dirname(current);
+      const parent = path12.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -2981,13 +4180,13 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
   const results = /* @__PURE__ */ new Map();
   let root;
   try {
-    for (const name of fs10.readdirSync(os2.tmpdir())) {
-      const left = path10.join(os2.tmpdir(), name);
-      if (name.startsWith(JOBS_PREFIX) && Date.now() - fs10.statSync(left).mtimeMs > 36e5) {
-        fs10.rmSync(left, { recursive: true, force: true });
+    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 = fs10.realpathSync(fs10.mkdtempSync(path10.join(os2.tmpdir(), JOBS_PREFIX)));
+    root = fs12.realpathSync(fs12.mkdtempSync(path12.join(os2.tmpdir(), JOBS_PREFIX)));
   } catch {
     return results;
   }
@@ -3019,11 +4218,11 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
     await Promise.all(
       Array.from(
         { length: Math.min(jobs, gates.length) },
-        (_unused, index) => line(path10.join(root, `line-${index}`))
+        (_unused, index) => line(path12.join(root, `line-${index}`))
       )
     );
   } finally {
-    fs10.rmSync(root, { recursive: true, force: true });
+    fs12.rmSync(root, { recursive: true, force: true });
   }
   return results;
 }
@@ -3052,7 +4251,7 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
   const command = commandOverride.length > 0 ? commandOverride : resolveGateCommand(manifest);
   const [program, ...args] = command;
   const executable = findLocalBin(manifest.dir, program) ?? program;
-  const runGate = (env) => spawnSync3(executable, args, {
+  const runGate = (env) => spawnSync4(executable, args, {
     cwd: manifest.dir,
     env: {
       ...process.env,
@@ -3098,48 +4297,60 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
   const jobs = selection.jobs ?? 1;
   if (jobs > 1 && waiting.length > 1) {
     const known = knownCommand(program, args);
-    const configFile = gateConfigFile(args);
-    const ask = (loaded) => jobsRefused({
+    const refusal = jobsRefused({
       failurePattern: manifest.settings.selfcheckFailurePattern,
       command: known,
-      configSource: gateConfigSource(manifest, args),
-      ...loaded,
-      trusted: manifest.settings.importMode === "allowlist" ? manifest.settings.importAllow.flatMap(
-        (rule) => rule.module === void 0 ? [] : [rule.module]
-      ) : []
+      configSource: gateConfigSource(manifest, args)
     });
-    const refusal = ask({ files: [], lost: null }) ?? ask(loadedFiles(manifest, configFile));
     if (refusal !== null || !("runner" in known)) {
       io2.out(`test-gates selfcheck: one negative control at a time (${refusal})`);
     } else {
-      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, waiting, 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 = waiting.length - heldAtOnce.size;
-      if (again > 0) {
+      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: ${again} of ${waiting.length} negative control(s) did not hold cleanly next to others and run again on their own`
+          `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`
+          );
+        }
       }
     }
   }
@@ -3210,6 +4421,8 @@ Commands:
   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
+  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: .)
@@ -3218,6 +4431,9 @@ Options:
   --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
@@ -3250,8 +4466,10 @@ 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, args.gates);
+      return runMutation(args.dir, args.rest, io, args.gates, args.affected);
     case "mutation-result":
       return runMutationResult(args.dir, args.report, io);
     case "selfcheck":