@t09tanaka/test-gates 0.4.1 → 0.4.3

package/dist/cli.js

@@ -319,14 +319,17 @@ function parseImports(source) {
     const clause = match[3];
     const module = match[5];
     const braces = /\{([^}]*)\}/.exec(clause);
-    const names = braces ? braces[1].split(",").map((part) => part.trim()).filter((part) => part !== "" && !/^type\s/.test(part)).map((part) => part.split(/\s+as\s+/)[0].trim()) : [];
+    const entries = braces ? braces[1].split(",").map((part) => part.trim()).filter((part) => part !== "") : [];
+    const names = entries.filter((part) => !/^type\s/.test(part)).map((part) => part.split(/\s+as\s+/)[0].trim());
     const outsideBraces = clause.replace(/\{[^}]*\}/, "").replace(/,/g, "").trim();
     found.push({
       module,
       line: lineAt(source, match.index + match[0].lastIndexOf(module)),
       typeOnly: match[2] !== void 0,
       names,
-      whole: outsideBraces !== ""
+      whole: outsideBraces !== "",
+      ...match[2] === void 0 && outsideBraces === "" && entries.length > 0 && // `type as kind` imports the value named `type`.
+      entries.every((part) => /^type\s+(?!as\s)[\w$]/.test(part)) ? { inlineTypes: true } : {}
     });
   }
   for (const match of source.matchAll(SIDE_EFFECT_IMPORT)) {
@@ -341,6 +344,9 @@ function parseImports(source) {
   }
   for (const match of source.matchAll(CALL_IMPORT)) {
     const module = match[2];
+    if (match[1] === "`" && module.includes("${")) {
+      continue;
+    }
     found.push({
       module,
       line: lineAt(source, match.index + match[0].lastIndexOf(module)),
@@ -351,7 +357,7 @@ function parseImports(source) {
   }
   return found.sort((a, b) => a.line - b.line);
 }
-var COMPUTED_CALL_IMPORT = /(?<![.\w$])(?:require|import)\s*\(\s*(?!['"`\s)])/g;
+var COMPUTED_CALL_IMPORT = /(?<![.\w$])(?:require|import)\s*\((?!\s*(?:\)|(?:'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"|`(?:[^`\\$]|\\.|\$(?!\{))*`)\s*\)))/g;
 function findUncheckableImports(source) {
   return [...source.matchAll(COMPUTED_CALL_IMPORT)].map((match) => lineAt(source, match.index));
 }
@@ -378,7 +384,11 @@ function resolveSpecifier(specifier, fromFile, aliases) {
   const segments = [];
   for (const segment of joined.split("/")) {
     if (segment === "..") {
-      segments.pop();
+      if (segments.length === 0 || segments[segments.length - 1] === "..") {
+        segments.push(segment);
+      } else {
+        segments.pop();
+      }
     } else if (segment !== "." && segment !== "") {
       segments.push(segment);
     }
@@ -423,8 +433,8 @@ function findImporters(gatePath, others, aliases) {
       if (imported.typeOnly) {
         return false;
       }
-      const resolved = resolveSpecifier(imported.module, other.path, aliases);
-      return resolved === target || resolved === asDirectory;
+      const resolved2 = resolveSpecifier(imported.module, other.path, aliases);
+      return resolved2 === target || resolved2 === asDirectory;
     })
   ).map((other) => other.path);
 }
@@ -555,8 +565,8 @@ function scanSpecSource(gatePath, specPath, source, settings) {
   const gateDirectory = gateModule.replace(/\/index$/, "");
   for (const match of source.matchAll(MODULE_MOCK)) {
     const specifier = match[2];
-    const resolved = resolveSpecifier(specifier, specPath, settings.importAliases);
-    if (resolved === gateModule || resolved === gateDirectory) {
+    const resolved2 = resolveSpecifier(specifier, specPath, settings.importAliases);
+    if (resolved2 === gateModule || resolved2 === gateDirectory) {
       let line = 1;
       for (let i = 0; i < match.index; i += 1) {
         if (source[i] === "\n") {
@@ -1024,13 +1034,13 @@ function judgeSelfcheck(input) {
 function selectControls(input) {
   const { gates, mode, only, shard } = input;
   if (only.length > 0) {
-    const unknown = only.filter((path13) => !gates.includes(path13));
+    const unknown = only.filter((path15) => !gates.includes(path15));
     if (unknown.length > 0) {
       return {
         error: `--gate ${unknown.join(", ")}: not a gate of test-gates.json (write the path as it is written there)`
       };
     }
-    return { selected: gates.filter((path13) => only.includes(path13)) };
+    return { selected: gates.filter((path15) => only.includes(path15)) };
   }
   if (shard !== null) {
     if (shard.total > gates.length) {
@@ -1183,8 +1193,8 @@ function planControls(input) {
   if (silent !== void 0) {
     return everyoneAlone(`the gate run left no note for the spec of ${silent.path}`);
   }
-  const partsOf = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
-  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf(gate)) === "no");
+  const partsOf3 = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
+  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf3(gate)) === "no");
   if (short !== void 0) {
     return everyoneAlone(
       `the notes of the specs do not add up to what the runner counted for ${short.path}`
@@ -1198,7 +1208,7 @@ function planControls(input) {
     if (all.some((other) => other.path !== gate.path && other.path.includes(gate.path))) {
       return false;
     }
-    if (accountedFor(totals[gate.file], partsOf(gate)) !== "yes") {
+    if (accountedFor(totals[gate.file], partsOf3(gate)) !== "yes") {
       return false;
     }
     const touching = notes.filter((note) => {
@@ -1409,207 +1419,630 @@ function runCheck(dir, io2) {
 }
 
 // src/commands/doctor.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import fs9 from "fs";
-import path9 from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+import fs11 from "fs";
+import path11 from "path";
 
-// 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/core/mutation-result.ts
+var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
+var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
+function normalizeCode(text) {
+  return text.replace(/\s+/g, " ").trim();
 }
-var isStringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
-function parseAffected(value) {
-  const { tests, gates } = value ?? {};
-  if (!isStringList(tests) || typeof gates !== "object" || gates === null || Array.isArray(gates)) {
-    return null;
-  }
-  const parsed = /* @__PURE__ */ Object.create(null);
-  for (const [gate, entry] of Object.entries(gates)) {
-    const { specs, files } = entry ?? {};
-    if (!isStringList(specs) || !isStringList(files)) {
-      return null;
-    }
-    parsed[gate] = { specs, files };
-  }
-  return { tests, gates: parsed };
+function normalizePath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-function parseRecord(value) {
-  const { format, incremental, snapshot, affected } = value ?? {};
-  if (format !== RECORD_FORMAT || typeof incremental !== "string") {
-    return null;
-  }
-  if (typeof snapshot !== "object" || snapshot === null) {
-    return null;
-  }
-  const { mode, environment, args, files } = snapshot;
-  if (mode !== "git" && mode !== "walk") {
-    return null;
-  }
-  if (!isStringList(args) || !isStringRecord(environment) || !isStringRecord(files)) {
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function sliceByLocation(source, location) {
+  const lines = source.split("\n");
+  const { start, end } = location;
+  const first = lines[start.line - 1];
+  const last = lines[end.line - 1];
+  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
     return null;
   }
-  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;
+  if (start.line === end.line) {
+    return first.slice(start.column - 1, end.column - 1);
   }
-  return record;
-}
-function listed(names) {
-  const shown = names.slice(0, 3).join(", ");
-  return names.length > 3 ? `${shown} and ${names.length - 3} more` : shown;
+  return [
+    first.slice(start.column - 1),
+    ...lines.slice(start.line, end.line - 1),
+    last.slice(0, end.column - 1)
+  ].join("\n");
 }
-function differingKeys(before, after) {
-  return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((key) => before[key] !== after[key]).sort();
+function keyOf(mutator, original, replacement) {
+  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
 }
-function readRecord(input) {
-  if (input.record === void 0) {
-    return { refused: "there is no record of the run that wrote the incremental file" };
-  }
-  const record = parseRecord(input.record);
-  if (record === null) {
-    return { refused: "the record of the last run is not one this version can read" };
-  }
-  if (record.incremental !== input.incremental) {
-    return { refused: "the incremental file is not the one the last recorded run wrote" };
-  }
-  const before = record.snapshot;
-  const now = input.snapshot;
-  if (before.mode !== now.mode) {
-    return {
-      refused: `the files are listed in another way than in the last run (${before.mode}, now ${now.mode})`
-    };
-  }
-  const environment = differingKeys(before.environment, now.environment);
-  if (environment.length > 0) {
-    const changes = environment.map(
-      (key) => `${key} ${before.environment[key] ?? "none"} \u2192 ${now.environment[key] ?? "none"}`
-    );
-    return { refused: `the tools changed since the last run: ${listed(changes)}` };
+function locateMutants(source, mutants) {
+  const located = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const outside = [];
+  const sorted2 = [...mutants].sort(
+    (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
+  );
+  for (const mutant of sorted2) {
+    const original = sliceByLocation(normalizeNewlines(source), mutant.location);
+    if (original === null) {
+      outside.push(mutant);
+      continue;
+    }
+    const replacement = mutant.replacement ?? "";
+    const key = keyOf(mutant.mutatorName, original, replacement);
+    const group = byKey.get(key) ?? [];
+    const entry = { mutant, original, replacement, occurrence: group.length + 1, sameKeyCount: 0 };
+    group.push(entry);
+    byKey.set(key, group);
+    located.push(entry);
   }
-  if (JSON.stringify(before.args) !== JSON.stringify(now.args)) {
-    return { refused: "the arguments for Stryker are not those of the last run" };
+  for (const group of byKey.values()) {
+    for (const entry of group) {
+      entry.sameKeyCount = group.length;
+    }
   }
-  return { record };
+  return { located, byKey, outside };
 }
-function refuseReuse(input) {
-  const read2 = readRecord(input);
-  if ("refused" in read2) {
-    return read2.refused;
-  }
-  const files = differingKeys(read2.record.snapshot.files, input.snapshot.files);
-  if (files.length > 0) {
-    return `changed since the last run: ${listed(files)}`;
+function resolveEntry(entry, byKey) {
+  const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
+  if (entry.occurrence === void 0 && group.length > 1) {
+    return { ambiguous: group.length };
   }
-  return null;
-}
-function incrementalOptions(config, args) {
-  const options = typeof config === "object" && config !== null ? config : {};
-  const valueOf = (name) => {
-    let value;
-    args.forEach((arg, position) => {
-      if (arg === name) {
-        value = args[position + 1];
-      } else if (arg.startsWith(`${name}=`)) {
-        value = arg.slice(name.length + 1);
-      }
-    });
-    return value;
-  };
-  const fromConfig = (name, fallback) => typeof options[name] === "string" ? options[name] : fallback;
-  return {
-    incremental: options.incremental === true || args.includes("--incremental"),
-    force: options.force === true || args.includes("--force"),
-    incrementalFile: valueOf("--incrementalFile") ?? fromConfig("incrementalFile", "reports/stryker-incremental.json"),
-    tempDirName: valueOf("--tempDirName") ?? fromConfig("tempDirName", ".stryker-tmp")
-  };
-}
-function comparableArgs(args) {
-  return args.filter((arg) => arg !== "--force");
+  return { target: group[(entry.occurrence ?? 1) - 1] };
 }
-
-// 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";
+function expectedTimeoutMutants(gate, source, mutants) {
+  const pointed = /* @__PURE__ */ new Set();
+  if (source === void 0 || !Array.isArray(gate.expectedTimeouts)) {
+    return pointed;
   }
-  if (!inside || segments.length === 1 || !PASSIVE.test(name)) {
-    return "other";
+  const { byKey, outside } = locateMutants(source, mutants);
+  if (outside.length > 0) {
+    return pointed;
   }
-  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);
-      }
+  for (const entry of gate.expectedTimeouts) {
+    if (!isUsableEquivalentMutant(entry)) {
+      continue;
     }
-    const files = new Set(closureOf(gate.key));
-    for (const spec of specs) {
-      closureOf(spec).forEach((file) => files.add(file));
+    const found = resolveEntry(entry, byKey);
+    if ("target" in found && found.target !== void 0) {
+      pointed.add(found.target.mutant);
     }
-    result[gate.key] = { specs: [...specs].sort(), files: [...files].sort() };
   }
-  return result;
+  return pointed;
 }
-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)}` };
+function describeMutant(file, entry) {
+  const { mutant } = entry;
+  return {
+    file,
+    line: mutant.location.start.line,
+    column: mutant.location.start.column,
+    status: mutant.status,
+    mutator: mutant.mutatorName,
+    original: normalizeCode(entry.original),
+    replacement: normalizeCode(entry.replacement),
+    occurrence: entry.occurrence,
+    sameKeyCount: entry.sameKeyCount,
+    allowance: {
+      mutator: mutant.mutatorName,
+      original: normalizeCode(entry.original),
+      replacement: normalizeCode(entry.replacement),
+      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
+      reason: ""
+    }
+  };
+}
+function describeAllowance(entry) {
+  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
+  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+}
+function judgeMutationReport(input) {
+  const violations = [];
+  const survivors = [];
+  const unexpectedTimeouts = [];
+  const summary = {
+    total: 0,
+    detected: 0,
+    timeout: 0,
+    allowed: 0,
+    notEvaluable: 0,
+    unallowed: 0,
+    expectedTimeout: 0
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, result] of Object.entries(input.report.files ?? {})) {
+    files.set(normalizePath(file), result);
   }
-  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: [] });
+    const gatePath = normalizePath(gate.path);
+    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
+    violations.push(...shapeViolations);
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
+    const result = files.get(gatePath);
+    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: "no mutants in the report (the gate was not mutation tested)"
+      });
       continue;
     }
-    const files = [.../* @__PURE__ */ new Set([...last.files, ...gate.files])];
+    const diskSource = input.readSource(gate.path);
+    const source = result.source ?? diskSource;
+    if (source === void 0) {
+      violations.push({
+        file: gate.path,
+        message: "source is neither in the report nor readable on disk"
+      });
+      continue;
+    }
+    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
+      violations.push({
+        file: gate.path,
+        message: "the report was made from a different version of this file. Run Stryker again"
+      });
+      continue;
+    }
+    const { located, byKey, outside } = locateMutants(source, result.mutants);
+    for (const mutant of outside) {
+      violations.push({
+        file: gate.path,
+        line: mutant.location.start.line,
+        message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
+      });
+    }
+    if (outside.length > 0) {
+      continue;
+    }
+    const claim = (field, entries, noun, accept) => {
+      const claimed = /* @__PURE__ */ new Set();
+      if (!Array.isArray(entries)) {
+        return claimed;
+      }
+      entries.forEach((entry, index) => {
+        if (!isUsableEquivalentMutant(entry)) {
+          return;
+        }
+        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
+        const found = resolveEntry(entry, byKey);
+        if ("ambiguous" in found) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: matches ${found.ambiguous} mutants in the file. Add "occurrence" (1-based) to pick one`
+          });
+          return;
+        }
+        const target = found.target;
+        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
+        if (!target || refusal !== null) {
+          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
+          return;
+        }
+        if (claimed.has(target)) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: another ${noun} already covers this mutant`
+          });
+          return;
+        }
+        claimed.add(target);
+      });
+      return claimed;
+    };
+    const allowed = claim(
+      "equivalentMutants",
+      gate.equivalentMutants,
+      "allowance",
+      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
+    );
+    const expected = claim(
+      "expectedTimeouts",
+      gate.expectedTimeouts,
+      "entry",
+      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
+    );
+    for (const entry of located) {
+      const { mutant } = entry;
+      summary.total += 1;
+      if (DETECTED.has(mutant.status)) {
+        summary.detected += 1;
+        if (mutant.status === "Timeout") {
+          summary.timeout += 1;
+          if (expected.has(entry)) {
+            summary.expectedTimeout += 1;
+          } else {
+            unexpectedTimeouts.push(describeMutant(gate.path, entry));
+          }
+        }
+      } else if (NOT_EVALUABLE.has(mutant.status)) {
+        summary.notEvaluable += 1;
+      } else if (SURVIVED.has(mutant.status)) {
+        if (allowed.has(entry)) {
+          summary.allowed += 1;
+          continue;
+        }
+        summary.unallowed += 1;
+        survivors.push(describeMutant(gate.path, entry));
+      } else {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
+        });
+      }
+    }
+  }
+  if (summary.total === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "no mutants were evaluated (the mutation test ran on nothing)"
+    });
+  }
+  const maxTimeouts = input.maxTimeouts ?? 0;
+  if (unexpectedTimeouts.length > maxTimeouts) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
+    });
+  }
+  return { violations, survivors, unexpectedTimeouts, summary };
+}
+var UNKNOWN_TEST = "not-in-the-first-run:";
+function sameMutant(a, b) {
+  return a.mutatorName === b.mutatorName && (a.replacement ?? "") === (b.replacement ?? "") && a.location.start.line === b.location.start.line && a.location.start.column === b.location.start.column && a.location.end.line === b.location.end.line && a.location.end.column === b.location.end.column;
+}
+function mergeRetry(first, retry, gates) {
+  const outcome = { retried: 0, statuses: {}, missing: 0 };
+  const firstId = translator(first, retry);
+  const files = { ...first.files };
+  const again = retry.files ?? {};
+  for (const named of gates) {
+    const gate = named.path.split("/").filter((part) => part !== ".").join("/");
+    const result = Object.hasOwn(files, gate) ? files[gate] : void 0;
+    if (result?.mutants === void 0) {
+      continue;
+    }
+    const expected = expectedTimeoutMutants(named, result.source, result.mutants);
+    const rerun = Object.hasOwn(again, gate) ? again[gate]?.mutants : void 0;
+    files[gate] = {
+      ...result,
+      mutants: result.mutants.map((mutant) => {
+        if (mutant.status !== "Timeout" || expected.has(mutant)) {
+          return mutant;
+        }
+        outcome.retried += 1;
+        const found = rerun?.find((other) => sameMutant(other, mutant));
+        if (found === void 0) {
+          outcome.missing += 1;
+          return mutant;
+        }
+        outcome.statuses[found.status] = (outcome.statuses[found.status] ?? 0) + 1;
+        return {
+          ...found,
+          ...found.coveredBy === void 0 ? {} : { coveredBy: found.coveredBy.map(firstId) },
+          ...found.killedBy === void 0 ? {} : { killedBy: found.killedBy.map(firstId) }
+        };
+      })
+    };
+  }
+  return { report: { ...first, files }, outcome };
+}
+function testKey(file, test) {
+  const start = test.location?.start;
+  return JSON.stringify([file, test.name ?? "", start?.line, start?.column]);
+}
+function* keyedTests(report) {
+  for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
+    if (entry.tests !== void 0) {
+      for (const test of entry.tests) {
+        yield { id: test.id, key: testKey(file, test) };
+      }
+    }
+  }
+}
+function translator(first, retry) {
+  const firstIds = /* @__PURE__ */ new Map();
+  for (const { id, key } of keyedTests(first)) {
+    firstIds.set(key, firstIds.has(key) ? null : id);
+  }
+  const ids = /* @__PURE__ */ new Map();
+  for (const { id, key } of keyedTests(retry)) {
+    ids.set(id, firstIds.get(key));
+  }
+  return (id) => {
+    const found = ids.get(id);
+    return typeof found === "string" ? found : `${UNKNOWN_TEST}${id}`;
+  };
+}
+function formatRetry(outcome) {
+  const statuses = Object.entries(outcome.statuses).sort(([a], [b]) => a.localeCompare(b)).map(([status, count]) => `${count} ${status}`);
+  if (outcome.missing > 0) {
+    statuses.push(`${outcome.missing} not in the report (still Timeout)`);
+  }
+  return `test-gates mutation: ${outcome.retried} mutant(s) that timed out were run again one at a time (--concurrency 1): ${statuses.join(", ")}`;
+}
+function formatSurvivor(survivor) {
+  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
+  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+}
+function formatSummary(summary) {
+  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+}
+
+// src/core/reuse-guard.ts
+var RECORD_FORMAT = 3;
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+var isStringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+function parseAffected(value) {
+  const { tests, gates } = value ?? {};
+  if (!isStringList(tests) || typeof gates !== "object" || gates === null || Array.isArray(gates)) {
+    return null;
+  }
+  const parsed = /* @__PURE__ */ Object.create(null);
+  for (const [gate, entry] of Object.entries(gates)) {
+    const { specs, files, blind } = entry ?? {};
+    if (!isStringList(specs) || !isStringList(files)) {
+      return null;
+    }
+    if (blind !== void 0 && typeof blind !== "string") {
+      return null;
+    }
+    parsed[gate] = { specs, files, ...blind === void 0 ? {} : { blind } };
+  }
+  return { tests, gates: parsed };
+}
+function parseRecord(value) {
+  const { format, incremental, snapshot, affected } = value ?? {};
+  if (format !== RECORD_FORMAT || typeof incremental !== "string") {
+    return null;
+  }
+  if (typeof snapshot !== "object" || snapshot === null) {
+    return null;
+  }
+  const { mode, environment, args, files } = snapshot;
+  if (mode !== "git" && mode !== "walk") {
+    return null;
+  }
+  if (!isStringList(args) || !isStringRecord(environment) || !isStringRecord(files)) {
+    return null;
+  }
+  const record = { format, incremental, snapshot: { mode, environment, args, files } };
+  if (affected !== void 0) {
+    const parsed = parseAffected(affected);
+    if (parsed === null) {
+      return null;
+    }
+    record.affected = parsed;
+  }
+  return record;
+}
+function listed(names) {
+  const shown = names.slice(0, 3).join(", ");
+  return names.length > 3 ? `${shown} and ${names.length - 3} more` : shown;
+}
+function differingKeys(before, after) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((key) => before[key] !== after[key]).sort();
+}
+function readRecord(input) {
+  if (input.record === void 0) {
+    return { refused: "there is no record of the run that wrote the incremental file" };
+  }
+  const record = parseRecord(input.record);
+  if (record === null) {
+    return { refused: "the record of the last run is not one this version can read" };
+  }
+  if (record.incremental !== input.incremental) {
+    return { refused: "the incremental file is not the one the last recorded run wrote" };
+  }
+  const before = record.snapshot;
+  const now = input.snapshot;
+  if (before.mode !== now.mode) {
+    return {
+      refused: `the files are listed in another way than in the last run (${before.mode}, now ${now.mode})`
+    };
+  }
+  const environment = differingKeys(before.environment, now.environment);
+  if (environment.length > 0) {
+    const changes = environment.map(
+      (key) => `${key} ${before.environment[key] ?? "none"} \u2192 ${now.environment[key] ?? "none"}`
+    );
+    return { refused: `the tools changed since the last run: ${listed(changes)}` };
+  }
+  if (JSON.stringify(before.args) !== JSON.stringify(now.args)) {
+    return { refused: "the arguments for Stryker are not those of the last run" };
+  }
+  return { record };
+}
+function refuseReuse(input) {
+  const read2 = readRecord(input);
+  if ("refused" in read2) {
+    return read2.refused;
+  }
+  const files = differingKeys(read2.record.snapshot.files, input.snapshot.files);
+  if (files.length > 0) {
+    return `changed since the last run: ${listed(files)}`;
+  }
+  return null;
+}
+function incrementalOptions(config, args) {
+  const options = typeof config === "object" && config !== null ? config : {};
+  const valueOf = (name) => {
+    let value;
+    args.forEach((arg, position) => {
+      if (arg === name) {
+        value = args[position + 1];
+      } else if (arg.startsWith(`${name}=`)) {
+        value = arg.slice(name.length + 1);
+      }
+    });
+    return value;
+  };
+  const fromConfig = (name, fallback) => typeof options[name] === "string" ? options[name] : fallback;
+  return {
+    incremental: options.incremental === true || args.includes("--incremental"),
+    force: options.force === true || args.includes("--force"),
+    incrementalFile: valueOf("--incrementalFile") ?? fromConfig("incrementalFile", "reports/stryker-incremental.json"),
+    tempDirName: valueOf("--tempDirName") ?? fromConfig("tempDirName", ".stryker-tmp")
+  };
+}
+function comparableArgs(args) {
+  return args.filter((arg) => arg !== "--force");
+}
+function objectOf(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function reportFiles(config) {
+  const options = objectOf(config);
+  const fileName = (reporter, fallback) => {
+    const named = objectOf(options[reporter]).fileName;
+    return typeof named === "string" ? named : fallback;
+  };
+  return [
+    fileName("htmlReporter", "reports/mutation/mutation.html"),
+    fileName("jsonReporter", "reports/mutation/mutation.json")
+  ];
+}
+var WILDCARDS = /* @__PURE__ */ new Map([
+  ["**/", "(?:.*/)?"],
+  ["*", "[^/]*"],
+  ["?", "[^/]"]
+]);
+function globSource(glob) {
+  return glob.split(/(\*\*\/|\*|\?)/).map((part) => WILDCARDS.get(part) ?? part.replace(/\W/g, "\\$&")).join("");
+}
+function strykerIgnores(config) {
+  const patterns = [objectOf(config).ignorePatterns].flat().filter((pattern) => typeof pattern === "string");
+  if (patterns.some((pattern) => pattern.startsWith("!"))) {
+    return () => false;
+  }
+  const rules = patterns.map((pattern) => {
+    const directoryOnly = pattern.endsWith("/");
+    const body = pattern.replace(/\/+$/, "");
+    const anchored = body.includes("/");
+    const expression = new RegExp(`^${globSource(body.replace(/^\//, ""))}$`, "i");
+    return { directoryOnly, anchored, expression };
+  });
+  return (relative) => {
+    const parts = relative.split("/");
+    return rules.some(
+      (rule) => parts.some((part, index) => {
+        if (rule.directoryOnly && index === parts.length - 1) {
+          return false;
+        }
+        const target = rule.anchored ? parts.slice(0, index + 1).join("/") : part;
+        return rule.expression.test(target);
+      })
+    );
+  };
+}
+
+// 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 ROOT_MOCKS = "__mocks__";
+var DOCUMENT = /\.(?:md|markdown|txt|rst|adoc|html?)$/i;
+var ENTRY_PAGE = /^index\.html?$/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 segments = localSegments(key, subproject);
+  const name = segments[segments.length - 1];
+  if (segments[0] === ROOT_MOCKS || segments.includes("node_modules") || CONFIG_NAMES.some((pattern) => pattern.test(name))) {
+    return "config";
+  }
+  if (isNestedMock(key, subproject)) {
+    return "other";
+  }
+  if (DOCUMENT.test(name) && !ENTRY_PAGE.test(name)) {
+    return "document";
+  }
+  const inside = subproject === "" || key.startsWith(`${subproject}/`);
+  if (!inside || segments.length === 1 || !PASSIVE.test(name)) {
+    return "other";
+  }
+  return "passive";
+}
+function localSegments(key, subproject) {
+  return (key.startsWith(`${subproject}/`) ? key.slice(subproject.length + 1) : key).split("/");
+}
+function isNestedMock(key, subproject) {
+  return localSegments(key, subproject).slice(1, -1).includes(ROOT_MOCKS);
+}
+function gateDependencies(input) {
+  const closureOf = (key) => Object.hasOwn(input.closures, key) ? input.closures[key] : [key];
+  const blind = input.blind ?? {};
+  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));
+    }
+    const sorted2 = [...files].sort();
+    const reason = sorted2.find((file) => Object.hasOwn(blind, file));
+    result[gate.key] = {
+      specs: [...specs].sort(),
+      files: sorted2,
+      ...reason === void 0 ? {} : { blind: blind[reason] }
+    };
+  }
+  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 in CI, with an older version, or could not tell)"
+    };
+  }
+  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) || // A mock that is gone may have been one of a package, which is used by name for every spec.
+    isNestedMock(key, input.subproject) && !Object.hasOwn(input.now, 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 blind = gate.blind ?? last.blind;
+    if (blind !== void 0) {
+      if (changed.length > 0 || input.seeded === true) {
+        rerun.push({ gate: gate.path, changed, blind });
+      } else {
+        reused.push(gate.path);
+      }
+      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 });
@@ -1624,23 +2057,33 @@ function withoutDots(file) {
 }
 function timeoutRanges(last, gates) {
   const ranges = [];
+  const rerun = /* @__PURE__ */ new Set();
+  const taken = /* @__PURE__ */ new Set();
   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) {
+    const gate = withoutDots(named.path);
+    const result = Object.hasOwn(files, gate) ? files[gate] : void 0;
+    if (result?.mutants === void 0) {
       continue;
     }
+    const { mutants } = result;
+    const expected = expectedTimeoutMutants(named, result.source, mutants);
     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}`);
+      if (mutant.status !== "Timeout") {
+        continue;
+      }
+      if (expected.has(mutant)) {
+        taken.add(mutant);
+        continue;
       }
+      rerun.add(mutant);
+      const { start, end } = mutant.location;
+      ranges.push(`${gate}:${start.line}:${start.column - 1}-${end.line}:${end.column}`);
     }
   }
-  return [...new Set(ranges)];
+  return { ranges: [...new Set(ranges)], rerun: rerun.size, expected: taken.size };
 }
-function describePlan(plan, shown = 5, timeouts = 0) {
+function describePlan(plan, shown = 5, timeouts = 0, expected = 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}`
@@ -1650,19 +2093,35 @@ function describePlan(plan, shown = 5, timeouts = 0) {
   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)) {
+  const told = plan.rerun.filter((entry) => entry.blind === void 0);
+  for (const { gate, changed } of told.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 (told.length > shown) {
+    lines.push(`  and ${told.length - shown} more`);
+  }
+  const reasons = [
+    ...new Set(plan.rerun.flatMap((entry) => entry.blind === void 0 ? [] : [entry.blind]))
+  ];
+  if (reasons.length > 0) {
+    const more = reasons.length > 1 ? ` (and ${reasons.length - 1} more reason(s))` : "";
+    lines.push(
+      `  ${plan.rerun.length - told.length} gate(s) run again for any change, as what they depend on cannot be told: ${reasons[0]}${more}`
+    );
   }
   if (timeouts > 0) {
     lines.push(`  and ${timeouts} mutant(s) of reused gates that timed out in the last run`);
   }
+  if (expected > 0) {
+    lines.push(`  ${describeExpected(expected)}`);
+  }
   return lines;
 }
+function describeExpected(expected) {
+  return `${expected} mutant(s) that timed out in the last run are taken over: expectedTimeouts lists them`;
+}
 
 // src/core/doctor.ts
 var NOT_THE_HELPER = "the runner config is not made with";
@@ -1697,12 +2156,22 @@ function diagnose(facts) {
       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"
     });
   }
+  const everyBlind = facts.blindGates.length >= facts.gates;
   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"
     });
+  } else if (facts.blindGates.length > 0) {
+    const gates = facts.blindGates.map((one) => one.gate);
+    const reasons = [...new Set(facts.blindGates.map((one) => one.reason))];
+    const more = reasons.length > 1 ? ` (and ${reasons.length - 1} more reason(s))` : "";
+    findings.push({
+      level: everyBlind && facts.hooks.some((hook) => hook.affected) ? "problem" : "note",
+      text: `with --affected, a change of any file runs ${gates.length} of ${facts.gates} gate(s) again (${listed(gates)}): what they depend on cannot be told (${reasons[0]}${more})`,
+      fix: "keep what reads files by a path no import names out of what those gates and their specs import"
+    });
   }
   if (facts.scope !== null && "every" in facts.scope) {
     findings.push({
@@ -1711,6 +2180,21 @@ function diagnose(facts) {
       fix: facts.scope.every.startsWith(NOT_THE_HELPER) ? "make the runner config with createJestGatesConfig or createVitestGatesConfig" : null
     });
   }
+  if (facts.sandboxes !== null) {
+    const { tempDir, count, kept, running } = facts.sandboxes;
+    findings.push(
+      running === null ? {
+        level: "note",
+        text: `${count} sandbox(es) an interrupted Stryker run left in ${tempDir}: a tool that walks the subproject (a test runner, a script) finds a copy of every file in them`,
+        fix: kept === null ? "the next test-gates mutation removes them" : `remove them by hand; the next test-gates mutation keeps them, because ${kept}`
+      } : {
+        // The sandboxes may be those of that run: removing them would break it.
+        level: "note",
+        text: `another test-gates mutation is running in this subproject (pid ${running}): the ${count} sandbox(es) in ${tempDir} are in use`,
+        fix: "leave them; the first test-gates mutation after that run ends removes what is left"
+      }
+    );
+  }
   if (facts.hooks.length === 0) {
     findings.push({
       level: "note",
@@ -1718,7 +2202,8 @@ function diagnose(facts) {
       fix: null
     });
   }
-  for (const hook of facts.hooks.filter((one) => !one.affected && facts.blind === null)) {
+  const toldApart = facts.blind === null && !everyBlind;
+  for (const hook of facts.hooks.filter((one) => !one.affected && toldApart)) {
     findings.push({
       level: "problem",
       text: `${hook.file} runs test-gates mutation without --affected: a change of any file of the subproject runs every mutant`,
@@ -1744,86 +2229,399 @@ function formatFindings(findings) {
 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/;
+var NONE = [];
+var COMMAND = String.raw`(?<=(?:^|[\n;&|(){]|\b(?:then|else|do))\s*)`;
+var TOKEN = new RegExp(
+  String.raw`\n|;;&?|;&|${COMMAND}(?:case\s+(\S+)\s+in|for\s+(\w+)(?:\s+in\s+([^;\n]*))?|(esac|do|done))(?![\w-])`,
+  "g"
+);
+var PATTERN = /\s*(?:esac(?![\w-])|\(?([^()\n;]*)\))/y;
+var VARIABLE = /^("?)\$(?:(\w+)|\{(\w+)\})\1$/;
+var REFERENCE = /\$(?:(\w+)|\{(\w+)\})/g;
+function namesOf(words) {
+  const names = words.map((word) => word.trim().replace(/^(["'])(.*)\1$/, "$2"));
+  return names.some((name) => name === "" || /[$*?[{}~\\`"']/.test(name)) ? null : names;
+}
+function partsOf(text) {
+  const parts = [];
+  let scopes = NONE;
+  let start = 0;
+  let loop = null;
+  const enter = (scope) => {
+    scopes = [...scopes, scope];
+  };
+  const leave = (kind) => {
+    const left = scopes.at(-1)?.kind === kind;
+    scopes = scopes.slice(0, -1);
+    return left;
+  };
+  TOKEN.lastIndex = 0;
+  for (; ; ) {
+    const token = TOKEN.exec(text);
+    parts.push({ text: text.slice(start, token?.index), scopes });
+    if (token === null) {
+      return scopes.length === 0 ? parts : null;
+    }
+    const [word, subject, variable, list, keyword] = token;
+    let awaiting = false;
+    if (subject !== void 0) {
+      const named = VARIABLE.exec(subject);
+      enter({
+        kind: "case",
+        id: /* @__PURE__ */ Symbol(),
+        variable: named?.[2] ?? named?.[3] ?? null,
+        names: null
+      });
+      awaiting = true;
+    } else if (variable !== void 0) {
+      loop = {
+        kind: "loop",
+        id: /* @__PURE__ */ Symbol(),
+        variable,
+        names: list === void 0 ? null : namesOf(list.trim().split(/\s+/))
+      };
+    } else if (keyword === "do") {
+      enter(loop ?? { kind: "loop", id: /* @__PURE__ */ Symbol(), variable: null, names: null });
+      loop = null;
+    } else if (keyword === "done" || keyword === "esac") {
+      if (!leave(keyword === "done" ? "loop" : "case")) {
+        return null;
+      }
+    } else if (word === ";&") {
+      return null;
+    } else if (word !== "\n") {
+      if (scopes.at(-1)?.kind !== "case") {
+        return null;
+      }
+      awaiting = true;
+    }
+    start = TOKEN.lastIndex;
+    if (awaiting) {
+      PATTERN.lastIndex = start;
+      const pattern = PATTERN.exec(text);
+      if (pattern === null) {
+        return null;
+      }
+      start = PATTERN.lastIndex;
+      TOKEN.lastIndex = start;
+      const top = scopes.at(-1);
+      scopes = scopes.slice(0, -1);
+      if (pattern[1] !== void 0) {
+        enter({ ...top, names: namesOf(pattern[1].split("|")) });
+      }
+    }
+  }
+}
+function sibling(of, scopes) {
+  const apart = of.findIndex((scope, at) => scope !== scopes[at]);
+  return apart !== -1 && of[apart].id === scopes[apart]?.id;
+}
+function expansions(target, scopes) {
+  return [...target.matchAll(REFERENCE)].reduce(
+    (words, [reference, plain2, braced]) => {
+      const names = [...scopes].reverse().find((scope) => scope.variable === (plain2 ?? braced))?.names ?? [reference];
+      return words.flatMap((word) => names.map((name) => word.replace(reference, name)));
+    },
+    [target]
+  );
+}
 function hookUses(input) {
   const lines = input.text.split("\n").map((line) => line.replace(/(?:^|\s)#.*/, ""));
+  const parts = partsOf(lines.join("\n")) ?? lines.map((text) => ({ text, scopes: NONE }));
   const uses = [];
-  lines.forEach((line, index) => {
-    if (!RUNS_MUTATION.test(line)) {
+  const cds = parts.map((part) => ({ cd: CD.exec(part.text)?.[2], scopes: part.scopes }));
+  parts.forEach((part, index) => {
+    if (!RUNS_MUTATION.test(part.text)) {
       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;
+    const named = TARGET.exec(part.text) ?? CD.exec(part.text);
+    const before = cds.slice(0, index).reverse().find((one) => one.cd !== void 0 && !sibling(one.scopes, part.scopes));
+    const target = named?.[2] ?? before?.cd;
+    const scopes = named !== null || before?.scopes === part.scopes ? part.scopes : NONE;
+    const ours = target === void 0 || expansions(target, scopes).some((word) => {
+      const normalized = word.split("/").filter((one) => one !== "." && one !== "").join("/");
+      return 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")
+        affected: /--affected\b/.test(part.text) || /test:gates:mutation\b/.test(part.text) && input.script.includes("--affected")
       });
     }
   });
   return uses;
 }
 
-// src/snapshot.ts
+// src/sandboxes.ts
 import { spawnSync } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/sandboxes.ts
+var SANDBOX = /^sandbox-[A-Za-z0-9]{6}$/;
+var MARKER = /^test-gates-run-([1-9][0-9]*)$/;
+function markerName(pid) {
+  return `test-gates-run-${pid}`;
+}
+function markerText(pid, started) {
+  return `${pid}
+${started ?? ""}
+`;
+}
+function markerAlive(input) {
+  const recorded = input.text?.split("\n")[1]?.trim() || null;
+  return input.there && (recorded === null || input.started === null || sameStart(recorded, input.started));
+}
+var START_SLACK_SECONDS = 5;
+function sameStart(a, b) {
+  const difference = Math.abs(Date.parse(a) - Date.parse(b));
+  return Number.isNaN(difference) ? a === b : difference <= START_SLACK_SECONDS * 1e3;
+}
+function insideSubproject(tempDir) {
+  const parts = tempDir.split("/");
+  return !/^[A-Za-z]:/.test(tempDir) && parts.every((part) => part !== "" && part !== "." && part !== "..");
+}
+function planSandboxes(facts) {
+  const sandboxes = facts.entries.filter((entry) => entry.directory && SANDBOX.test(entry.name)).map((entry) => entry.name).sort();
+  if (facts.tempDir === null) {
+    return {
+      kept: sandboxes,
+      why: "the Stryker config could not be loaded to see where they are",
+      running: null
+    };
+  }
+  if (!insideSubproject(facts.tempDir)) {
+    return {
+      kept: sandboxes,
+      why: `tempDirName (${facts.tempDir}) is not a directory inside the subproject`,
+      running: null
+    };
+  }
+  if (facts.keeps) {
+    return { kept: sandboxes, why: "the Stryker config sets cleanTempDir: false", running: null };
+  }
+  const markers = [];
+  for (const entry of facts.entries) {
+    const pid = MARKER.exec(entry.name)?.[1];
+    if (pid === void 0 || entry.directory) {
+      continue;
+    }
+    if (facts.alive(Number(pid), entry.name)) {
+      return {
+        kept: sandboxes,
+        why: `another test-gates mutation is running in this subproject (pid ${pid})`,
+        running: Number(pid)
+      };
+    }
+    markers.push(entry.name);
+  }
+  return { remove: sandboxes, markers };
+}
+
+// src/sandboxes.ts
+function there(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function startedAt(pid) {
+  const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C" },
+    timeout: 5e3
+  });
+  const started = result.status === 0 ? result.stdout.trim() : "";
+  return started === "" ? null : started;
+}
+function alive(dir) {
+  return (pid, marker) => {
+    if (!there(pid)) {
+      return false;
+    }
+    let text = null;
+    try {
+      text = fs4.readFileSync(path4.join(dir, marker), "utf8");
+    } catch {
+    }
+    return markerAlive({ there: true, text, started: startedAt(pid) });
+  };
+}
+function relativeTempDir(subproject, dir) {
+  let real = dir;
+  try {
+    real = fs4.realpathSync(dir);
+  } catch {
+  }
+  return path4.relative(fs4.realpathSync(subproject), real).split(path4.sep).join("/");
+}
+function sandboxPlan(subproject, setting) {
+  const tempDir = setting.dir === null ? null : relativeTempDir(subproject, setting.dir);
+  let entries = [];
+  if (setting.dir !== null) {
+    try {
+      entries = fs4.readdirSync(setting.dir, { withFileTypes: true });
+    } catch {
+    }
+  }
+  const plan = planSandboxes({
+    tempDir,
+    entries: entries.map((entry) => ({ name: entry.name, directory: entry.isDirectory() })),
+    keeps: setting.keeps,
+    alive: alive(setting.dir ?? subproject)
+  });
+  return { plan, shown: tempDir ?? ".stryker-tmp" };
+}
+function removeStaleSandboxes(subproject, setting) {
+  const { plan, shown } = sandboxPlan(subproject, setting);
+  if ("kept" in plan) {
+    if (plan.kept.length === 0) {
+      return [];
+    }
+    return plan.running === null ? [
+      `test-gates mutation: ${plan.kept.length} sandbox(es) left in ${shown} by an earlier Stryker run are kept: ${plan.why}`
+    ] : [
+      `test-gates mutation: ${plan.why}, so the ${plan.kept.length} sandbox(es) in ${shown} are kept: they are in use`
+    ];
+  }
+  const dir = setting.dir;
+  for (const marker of plan.markers) {
+    try {
+      fs4.rmSync(path4.join(dir, marker), { force: true });
+    } catch {
+    }
+  }
+  const failed = [];
+  for (const sandbox of plan.remove) {
+    try {
+      fs4.rmSync(path4.join(dir, sandbox), { recursive: true, force: true });
+    } catch (error) {
+      failed.push(`${sandbox} (${error.message})`);
+    }
+  }
+  const removed = plan.remove.length - failed.length;
+  return [
+    ...removed > 0 ? [
+      `test-gates mutation: removed ${removed} sandbox(es) an earlier Stryker run left in ${shown}`
+    ] : [],
+    ...failed.length > 0 ? [`test-gates mutation: could not remove from ${shown}: ${failed.join(", ")}`] : []
+  ];
+}
+function markRun(subproject, setting) {
+  const dir = setting.dir;
+  if (dir === null || !insideSubproject(relativeTempDir(subproject, dir))) {
+    return () => void 0;
+  }
+  const marker = path4.join(dir, markerName(process.pid));
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+    if (!insideSubproject(relativeTempDir(subproject, dir))) {
+      return () => void 0;
+    }
+    fs4.writeFileSync(marker, markerText(process.pid, startedAt(process.pid)));
+  } catch {
+    return () => void 0;
+  }
+  return () => {
+    try {
+      fs4.rmSync(marker, { force: true });
+      fs4.rmdirSync(dir);
+    } catch {
+    }
+  };
+}
+
+// src/snapshot.ts
+import { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
-import fs5 from "fs";
+import fs6 from "fs";
 import { createRequire } from "module";
 import os from "os";
-import path5 from "path";
+import path6 from "path";
 
 // src/commands/loaded-files.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import { builtinModules } from "module";
-import path4 from "path";
+import path5 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;
+var RUNNER_LOAD = /\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule|createMockFromModule|genMockFromModule)\s*(?:<[^()\n]*>)?\s*\(\s*(['"`])([^'"`\n]+)\1/g;
 function isFile(file) {
   try {
-    return fs4.statSync(file).isFile();
+    return fs5.statSync(file, { throwIfNoEntry: false })?.isFile() === true;
   } catch {
     return false;
   }
 }
-function resolveFile(base, directory = true) {
-  const candidates = [
-    base,
-    ...EXTENSIONS.map((extension) => base + extension),
+var resolved = null;
+function resolving(read2) {
+  if (resolved !== null) {
+    return read2();
+  }
+  resolved = /* @__PURE__ */ new Map();
+  try {
+    return read2();
+  } finally {
+    resolved = null;
+  }
+}
+var DECLARATIONS = [".d.ts", ".d.mts", ".d.cts"];
+function resolveFiles(base, directory = true, declarations = true) {
+  const key = `${Number(directory)}${Number(declarations)}${base}`;
+  const known = resolved?.get(key);
+  if (known !== void 0) {
+    return [...known];
+  }
+  const found = filesOf(base, directory, declarations);
+  resolved?.set(key, found);
+  return [...found];
+}
+function filesOf(base, directory, declarations) {
+  const candidates = (extensions) => [
+    ...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}`)) : []
+    ...extensions.map((extension) => base.replace(/\.[cm]?jsx?$/, extension)),
+    ...directory ? extensions.map((extension) => path5.join(base, `index${extension}`)) : []
   ];
-  return candidates.find(isFile) ?? null;
+  const data = [`${base}.json`, ...directory ? [path5.join(base, "index.json")] : []];
+  const scripts = [.../* @__PURE__ */ new Set([base, ...candidates(EXTENSIONS), ...data])].filter(isFile);
+  return scripts.length > 0 || !declarations ? scripts : [...new Set(candidates(DECLARATIONS))].filter(isFile);
+}
+function resolveFile(base, directory = true, declarations = true) {
+  return resolveFiles(base, directory, declarations)[0] ?? 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))) {
+  for (let current = path5.dirname(from); ; current = path5.dirname(current)) {
+    if (fs5.existsSync(path5.join(current, "node_modules", name))) {
       return true;
     }
-    if (current === path4.dirname(current)) {
+    if (current === path5.dirname(current)) {
       return false;
     }
   }
 }
 function loadedFiles(manifest, configFile) {
+  return resolving(() => loadedFilesNow(manifest, configFile));
+}
+function loadedFilesNow(manifest, configFile) {
   const aliases = manifest.settings.importAliases;
-  const relative = (file) => path4.relative(manifest.dir, file).split(path4.sep).join("/");
+  const relative = (file) => path5.relative(manifest.dir, file).split(path5.sep).join("/");
   const target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFile(path4.resolve(path4.dirname(from), specifier));
+      return resolveFiles(path5.resolve(path5.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))
+    return alias === void 0 ? [] : resolveFiles(
+      path5.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
     );
   };
   const read2 = (file) => {
-    const source = fs4.readFileSync(file, "utf8");
+    const source = fs5.readFileSync(file, "utf8");
     const imports = parseImports(source).filter((ref) => !ref.typeOnly);
     const specifiers = [
       .../* @__PURE__ */ new Set([
@@ -1835,7 +2633,7 @@ function loadedFiles(manifest, configFile) {
     return { source, specifiers, strings };
   };
   const named = /* @__PURE__ */ new Set();
-  const configs = configFile === null ? [] : [path4.resolve(manifest.dir, configFile)];
+  const configs = configFile === null ? [] : [path5.resolve(manifest.dir, configFile)];
   const seenConfigs = new Set(configs);
   const entry = configs[0];
   for (let file = configs.shift(); file !== void 0; file = configs.shift()) {
@@ -1843,16 +2641,18 @@ function loadedFiles(manifest, configFile) {
     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);
+      const here = resolveFiles(path5.resolve(path5.dirname(file), stripped), false);
+      const found = here.length > 0 ? here : resolveFiles(path5.resolve(manifest.dir, stripped), false);
+      for (const one of found.filter((candidate) => SCRIPT.test(candidate))) {
+        named.add(one);
       }
     }
     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);
+      for (const found of target(specifier, file)) {
+        if (SCRIPT.test(found) && !seenConfigs.has(found)) {
+          seenConfigs.add(found);
+          configs.push(found);
+        }
       }
     }
   }
@@ -1869,10 +2669,10 @@ function loadedFiles(manifest, configFile) {
     for (const specifier of specifiers) {
       if (isProjectImport(specifier, aliases)) {
         const found = target(specifier, file);
-        if (found === null) {
+        if (found.length === 0) {
           lost ??= `${specifier} (imported by ${relative(file)})`;
         } else {
-          next.push(found);
+          next.push(...found);
         }
       } else if (specifier.startsWith("node:") || builtinModules.includes(specifier)) {
         imports.push({ specifier, builtin: true });
@@ -1883,10 +2683,7 @@ function loadedFiles(manifest, configFile) {
       }
     }
     for (const text of strings.filter((one) => one.startsWith("."))) {
-      const found = resolveFile(path4.resolve(path4.dirname(file), text));
-      if (found !== null) {
-        next.push(found);
-      }
+      next.push(...resolveFiles(path5.resolve(path5.dirname(file), text)));
     }
     const visited = {
       file: { path: relative(file), source, imports },
@@ -1916,7 +2713,7 @@ function loadedFiles(manifest, configFile) {
   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)]))
+    ...specs.map((spec) => closure(spec, [path5.join(manifest.dir, spec)]))
   ];
   return { files: [...known.values()].map((visited) => visited.file), roots };
 }
@@ -1957,27 +2754,28 @@ 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 DOCUMENTS = [".md", ".markdown", ".txt", ".rst", ".adoc", ".html", ".htm"];
 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 DOWNWARD = /(['"`])(\.\/[^'"`\n]*)\1/g;
 var isUpward = (segment) => segment.split("/").includes("..");
 function hashOf(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 function hashFile(file) {
   try {
-    return hashOf(fs5.readFileSync(file));
+    return hashOf(fs6.readFileSync(file));
   } catch {
     return null;
   }
 }
 function isInside(parent, child) {
-  const relative = path5.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+  const relative = path6.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
 }
 function toPosix(file) {
-  return file.split(path5.sep).join("/");
+  return file.split(path6.sep).join("/");
 }
 function gitEnvironment(env) {
   if (env.GIT_DIR === void 0 || env.GIT_WORK_TREE !== void 0) {
@@ -1988,7 +2786,7 @@ function gitEnvironment(env) {
   return rest;
 }
 function git(cwd, args) {
-  const result = spawnSync("git", args, {
+  const result = spawnSync2("git", args, {
     cwd,
     env: gitEnvironment(process.env),
     encoding: "utf8",
@@ -1996,9 +2794,12 @@ function git(cwd, args) {
   });
   return result.error || result.status !== 0 ? null : result.stdout;
 }
+function globLiteral(relative) {
+  return relative.replace(/[*?[\]\\]/g, "\\$&");
+}
 function gitLister(root) {
   return (directory, recursive) => {
-    const relative = toPosix(path5.relative(root, directory));
+    const relative = globLiteral(toPosix(path6.relative(root, directory)));
     const pattern = recursive ? `${relative === "" ? "" : `${relative}/`}**` : `${relative === "" ? "" : `${relative}/`}*`;
     const listed2 = git(root, [
       "ls-files",
@@ -2017,8 +2818,8 @@ function gitLister(root) {
 }
 function walkLister(root) {
   const walk = (directory, recursive, found) => {
-    for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
-      const file = path5.join(directory, entry.name);
+    for (const entry of fs6.readdirSync(directory, { withFileTypes: true })) {
+      const file = path6.join(directory, entry.name);
       if (NEVER.includes(entry.name)) {
         continue;
       }
@@ -2027,7 +2828,7 @@ function walkLister(root) {
           walk(file, true, found);
         }
       } else {
-        found.push(toPosix(path5.relative(root, file)));
+        found.push(toPosix(path6.relative(root, file)));
       }
     }
     return found;
@@ -2037,16 +2838,16 @@ function walkLister(root) {
 function upTo(from, to) {
   const directories = [from];
   while (directories[directories.length - 1] !== to) {
-    directories.push(path5.dirname(directories[directories.length - 1]));
+    directories.push(path6.dirname(directories[directories.length - 1]));
   }
   return directories;
 }
 function declaresWorkspaces(directory) {
-  if (fs5.existsSync(path5.join(directory, "pnpm-workspace.yaml"))) {
+  if (fs6.existsSync(path6.join(directory, "pnpm-workspace.yaml"))) {
     return true;
   }
   try {
-    const manifest = JSON.parse(fs5.readFileSync(path5.join(directory, "package.json"), "utf8"));
+    const manifest = JSON.parse(fs6.readFileSync(path6.join(directory, "package.json"), "utf8"));
     return manifest.workspaces !== void 0;
   } catch {
     return false;
@@ -2054,7 +2855,7 @@ function declaresWorkspaces(directory) {
 }
 function walkRoot(dir) {
   const candidates = withinBounds(dir);
-  const repository = candidates.find((directory) => fs5.existsSync(path5.join(directory, ".git")));
+  const repository = candidates.find((directory) => fs6.existsSync(path6.join(directory, ".git")));
   if (repository !== void 0) {
     return repository;
   }
@@ -2063,11 +2864,11 @@ function walkRoot(dir) {
 function withinBounds(dir) {
   let home = null;
   try {
-    home = fs5.realpathSync(os.homedir());
+    home = fs6.realpathSync(os.homedir());
   } catch {
   }
-  return upTo(dir, path5.parse(dir).root).filter(
-    (directory) => directory !== path5.parse(dir).root && (home === null || !isInside(directory, home))
+  return upTo(dir, path6.parse(dir).root).filter(
+    (directory) => directory !== path6.parse(dir).root && (home === null || !isInside(directory, home))
   );
 }
 function linkedPackages(nodeModules, root) {
@@ -2075,20 +2876,20 @@ function linkedPackages(nodeModules, root) {
   const visit = (directory, depth) => {
     let entries;
     try {
-      entries = fs5.readdirSync(directory, { withFileTypes: true });
+      entries = fs6.readdirSync(directory, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const file = path5.join(directory, entry.name);
+      const file = path6.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         let target;
         try {
-          target = fs5.realpathSync(file);
+          target = fs6.realpathSync(file);
         } catch {
           continue;
         }
-        if (target.split(path5.sep).includes("node_modules") || !fs5.statSync(target).isDirectory()) {
+        if (target.split(path6.sep).includes("node_modules") || !fs6.statSync(target).isDirectory()) {
           continue;
         }
         if (!isInside(root, target)) {
@@ -2110,11 +2911,11 @@ function installedVersion(start, name) {
   for (; ; ) {
     try {
       const manifest = JSON.parse(
-        fs5.readFileSync(path5.join(current, "node_modules", name, "package.json"), "utf8")
+        fs6.readFileSync(path6.join(current, "node_modules", name, "package.json"), "utf8")
       );
       return typeof manifest.version === "string" ? manifest.version : "unknown";
     } catch {
-      const parent = path5.dirname(current);
+      const parent = path6.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -2122,17 +2923,30 @@ function installedVersion(start, name) {
     }
   }
 }
+function nodeOnPath(cwd) {
+  const result = spawnSync2("node", ["--version"], {
+    cwd,
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    timeout: 3e4
+  });
+  const version = result.status === 0 ? result.stdout.trim() : "";
+  return version === "" ? {} : { "Node.js on PATH": version };
+}
 function ownVersion() {
   const { version } = createRequire(import.meta.url)("../package.json");
   return version;
 }
 function snapshotOf(input) {
-  const dir = fs5.realpathSync(input.dir);
+  return resolving(() => snapshotNow(input));
+}
+function snapshotNow(input) {
+  const dir = fs6.realpathSync(input.dir);
   const top = git(dir, ["rev-parse", "--show-toplevel"]);
-  let root = top === null ? dir : fs5.realpathSync(top.trim());
+  let root = top === null ? dir : fs6.realpathSync(top.trim());
   let lister = gitLister(root);
   let mode = "git";
-  const manifest = toPosix(path5.relative(root, path5.join(dir, "test-gates.json")));
+  const manifest = toPosix(path6.relative(root, path6.join(dir, "test-gates.json")));
   if (top === null || !lister(dir, false).includes(manifest)) {
     mode = "walk";
     root = walkRoot(dir);
@@ -2140,17 +2954,17 @@ function snapshotOf(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 followed = input.scope === void 0 ? null : input.scope(list(dir, true).map((file) => path6.join(listRoot, file)));
   const walk = walkLister(listRoot);
   const written = input.written.map((file) => {
-    const target = path5.resolve(dir, file);
+    const target = path6.resolve(dir, file);
     try {
-      return fs5.realpathSync(target);
+      return fs6.realpathSync(target);
     } catch {
       return target;
     }
   });
-  const swallowing = written.find((target) => isInside(target, path5.join(dir, "test-gates.json")));
+  const swallowing = written.find((target) => isInside(target, path6.join(dir, "test-gates.json")));
   if (swallowing !== void 0) {
     throw new SnapshotError(`the run writes to ${swallowing}, which holds test-gates.json`);
   }
@@ -2167,12 +2981,12 @@ function snapshotOf(input) {
     if (!isInside(listRoot, directory)) {
       const written2 = reference === void 0 ? "" : ` with ${JSON.stringify(reference)}`;
       throw new SnapshotError(
-        `${toPosix(path5.relative(dir, from))} points outside of what can be listed${written2} (${directory})`
+        `${toPosix(path6.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}`);
+      widened.push(`${toPosix(path6.relative(listRoot, from))}${written2}`);
     }
     if (![...queued].some((region) => isInside(region, directory))) {
       queued.add(directory);
@@ -2180,19 +2994,74 @@ function snapshotOf(input) {
     }
   };
   const follow = (fixed, open, anchored, file, reference) => {
-    const target = path5.resolve(path5.dirname(file), fixed);
-    let isDirectory = false;
+    const from = (start) => {
+      const target = path6.resolve(start, fixed);
+      let isDirectory2 = false;
+      try {
+        isDirectory2 = fs6.statSync(target).isDirectory();
+      } catch {
+      }
+      return {
+        target,
+        isDirectory: isDirectory2,
+        found: isDirectory2 || resolveFile(target, true, false) !== null
+      };
+    };
+    const fromFile = from(path6.dirname(file));
+    const targets = [fromFile];
+    if (!anchored && path6.dirname(file) !== dir) {
+      const fromRun = from(dir);
+      if (fromRun.found && !fromFile.found) {
+        targets[0] = fromRun;
+      } else if (fromRun.found && isInside(fromRun.target, listRoot)) {
+        enqueue(listRoot, file, reference);
+      } else if (fromRun.found) {
+        targets.push(fromRun);
+      }
+    }
+    for (const { target, isDirectory: isDirectory2 } of targets) {
+      const beside = (isDirectory2 || open ? [] : resolveFiles(target, false, false)).filter(
+        (one) => besideAncestors.has(one)
+      );
+      if (beside.length > 0) {
+        beside.forEach(reach);
+        continue;
+      }
+      if (!isDirectory2 && !isInside(listRoot, target) && resolveFile(target, true, false) === null) {
+        files[toPosix(path6.relative(listRoot, target))] = "missing";
+        continue;
+      }
+      const directory = isDirectory2 ? target : path6.dirname(target);
+      if (fs6.existsSync(directory)) {
+        enqueue(directory, file, reference, anchored && !open);
+      }
+    }
+  };
+  const reached = /* @__PURE__ */ new Set();
+  const reach = (file) => {
+    if (reached.has(file) || DOCUMENTS.includes(path6.extname(file).toLowerCase())) {
+      return;
+    }
+    reached.add(file);
+    let text;
     try {
-      isDirectory = fs5.statSync(target).isDirectory();
+      const content = fs6.readFileSync(file);
+      if (content.length > SCAN_LIMIT || content.subarray(0, 8e3).includes(0)) {
+        return;
+      }
+      text = content.toString("utf8").replace(/\\[\\/]/g, "/");
     } catch {
-    }
-    if (!isDirectory && !isInside(listRoot, target) && resolveFile(target) === null) {
-      files[toPosix(path5.relative(listRoot, target))] = "missing";
       return;
     }
-    const directory = isDirectory ? target : path5.dirname(target);
-    if (fs5.existsSync(directory)) {
-      enqueue(directory, file, reference, anchored && !open);
+    for (const match of text.matchAll(DOWNWARD)) {
+      const literal = match[2];
+      const open = literal.includes("${");
+      const fixed = open ? literal.slice(0, literal.lastIndexOf("/", literal.indexOf("${")) + 1) : literal;
+      if (open && isUpward(literal.slice(literal.indexOf("${")))) {
+        enqueue(listRoot, file, literal);
+      } else {
+        follow(fixed, open, false, file, literal);
+      }
     }
   };
   const scan = (text, file) => {
@@ -2208,7 +3077,7 @@ function snapshotOf(input) {
       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);
+      follow(path6.posix.join(...segments), open, true, file, reference);
     }
     for (const match of text.matchAll(UPWARD)) {
       const at = match.index ?? 0;
@@ -2228,70 +3097,91 @@ function snapshotOf(input) {
     }
   };
   const add = (relative) => {
-    const file = path5.join(listRoot, relative);
+    const file = path6.join(listRoot, relative);
     if (relative in files || written.some((target) => isInside(target, file))) {
       return;
     }
     let stat;
     try {
-      stat = fs5.lstatSync(file);
+      stat = fs6.lstatSync(file);
     } catch {
       files[relative] = "missing";
       return;
     }
     if (stat.isSymbolicLink()) {
-      files[relative] = `link ${fs5.readlinkSync(file)}`;
+      files[relative] = `link ${fs6.readlinkSync(file)}`;
       let target;
       try {
-        target = fs5.realpathSync(file);
+        target = fs6.realpathSync(file);
       } catch {
         return;
       }
-      enqueue(fs5.statSync(target).isDirectory() ? target : path5.dirname(target), file);
+      enqueue(fs6.statSync(target).isDirectory() ? target : path6.dirname(target), file);
     } else if (stat.isDirectory()) {
       files[relative] = "directory";
       walk(file, true).forEach(add);
     } else if (!stat.isFile()) {
       files[relative] = "special";
     } else {
-      const content = fs5.readFileSync(file);
+      const content = fs6.readFileSync(file);
       files[relative] = hashOf(content);
-      const document = DOCUMENTS.includes(path5.extname(file).toLowerCase());
+      const document = DOCUMENTS.includes(path6.extname(file).toLowerCase());
       const loaded = followed === null || !isInside(dir, file) || followed.has(file);
       if (loaded && !document && content.length <= SCAN_LIMIT && !content.subarray(0, 8e3).includes(0)) {
         scan(content.toString("utf8").replace(/\\[\\/]/g, "/"), file);
       }
     }
-  };
-  const ancestors = upTo(dir, listRoot).slice(1);
-  for (const directory of ancestors) {
-    list(directory, false).forEach(add);
+  };
+  const ancestors = upTo(dir, listRoot).slice(1);
+  const besideAncestors = /* @__PURE__ */ new Set();
+  const ancestorFiles = ancestors.flatMap((directory) => list(directory, false));
+  for (const relative of ancestorFiles) {
+    besideAncestors.add(path6.join(listRoot, relative));
+  }
+  ancestorFiles.forEach(add);
+  for (const directory of [dir, ...ancestors]) {
+    const patches = path6.join(directory, "patches");
+    if (fs6.existsSync(patches) && fs6.statSync(patches).isDirectory()) {
+      enqueue(patches, directory);
+    }
   }
   for (const directory of [dir, ...ancestors]) {
-    for (const linked of linkedPackages(path5.join(directory, "node_modules"), listRoot)) {
+    for (const linked of linkedPackages(path6.join(directory, "node_modules"), listRoot)) {
       if (!isInside(linked, dir)) {
-        enqueue(linked, path5.join(directory, "node_modules"));
+        enqueue(linked, path6.join(directory, "node_modules"));
       }
     }
   }
   const above = withinBounds(listRoot).slice(1);
   for (const directory of [dir, ...ancestors, ...above]) {
     const candidates = [
-      ...INSTALL_MARKERS.map((marker) => path5.join(directory, "node_modules", marker)),
-      ...above.includes(directory) ? LOCK_FILES.map((name) => path5.join(directory, name)) : []
+      ...INSTALL_MARKERS.map((marker) => path6.join(directory, "node_modules", marker)),
+      ...above.includes(directory) ? LOCK_FILES.map((name) => path6.join(directory, name)) : []
     ];
     for (const file of candidates) {
       const hash = hashFile(file);
       if (hash !== null) {
-        files[toPosix(path5.relative(listRoot, file))] = hash;
+        files[toPosix(path6.relative(listRoot, file))] = hash;
       }
     }
   }
-  for (let position = 0; position < regions.length; position += 1) {
-    list(regions[position], true).forEach(add);
+  let position = 0;
+  const drain = () => {
+    for (; position < regions.length; position += 1) {
+      list(regions[position], true).forEach(add);
+    }
+  };
+  drain();
+  for (const file of followed ?? []) {
+    const parts = path6.relative(listRoot, file).split(path6.sep);
+    if (isInside(listRoot, file) && !parts.some((part) => NEVER.includes(part)) && fs6.statSync(file, { throwIfNoEntry: false })?.isFile() === true) {
+      add(toPosix(path6.relative(listRoot, file)));
+    }
   }
+  drain();
   const environment = {
     "Node.js": process.version,
+    ...nodeOnPath(dir),
     platform: `${process.platform} ${process.arch}`,
     "test-gates": ownVersion()
   };
@@ -2305,12 +3195,26 @@ function snapshotOf(input) {
 }
 
 // src/affected-files.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import { builtinModules as builtinModules2 } from "module";
-import path6 from "path";
+import path7 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 RUNTIME_PATHS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readFile|readdirSync|fromFile|fromURL)\b|\bimport\.meta\.(?:glob|resolve)\b/;
+var PATH_FROM_TOP = /^[^\s./?#*:][^\s?#*:]*\.(?:html?|md|json)$/i;
+var withoutQuery = (specifier) => specifier.replace(/\?[^/]*$/, "");
+var RUNTIME_LOADS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire)\b|\bimport\.meta\.(?:glob|resolve)\b/;
+var LOCATION = /\b(?:__dirname|__filename)\b|\bimport\.meta\.(?:url|dirname|filename)\b/;
+var LOCATION_READS = /\b(?:readFile|readdir|readlink|existsSync|stat|statSync|lstat|lstatSync|access|accessSync|realpath|realpathSync|open|openSync|opendir|opendirSync|createReadStream|watch|watchFile|glob|globSync|promises)\b|\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule|setMock|createMockFromModule)\(\s*(?![\s'"`)])|\bWorker\(/;
+var LOCATION_LOADS = /\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule|setMock|createMockFromModule)\(\s*(?![\s'"`)])|\bWorker\(/;
+var LOCATION_SAFE = /* @__PURE__ */ new Set([
+  "path",
+  "path/posix",
+  "path/win32",
+  "url",
+  "vitest",
+  "@jest/globals"
+]);
 var FILE_MODULES = /* @__PURE__ */ new Set([
   "fs",
   "fs/promises",
@@ -2323,30 +3227,31 @@ var FILE_MODULES = /* @__PURE__ */ new Set([
   "fast-glob",
   "globby"
 ]);
+var LOADING_MODULES = /* @__PURE__ */ new Set(["child_process", "module", "worker_threads"]);
 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)) {
+  for (let current = path7.dirname(from); ; current = path7.dirname(current)) {
+    const candidate = path7.join(current, "node_modules", name);
+    if (fs7.existsSync(candidate)) {
       const target = realpath(candidate);
-      return target.split(path6.sep).includes("node_modules") ? null : target;
+      return target.split(path7.sep).includes("node_modules") ? null : target;
     }
-    if (current === path6.dirname(current)) {
+    if (current === path7.dirname(current)) {
       return null;
     }
   }
 }
-var toPosix2 = (file) => file.split(path6.sep).join("/");
+var toPosix2 = (file) => file.split(path7.sep).join("/");
 function realpath(file) {
   try {
-    return fs6.realpathSync.native(file);
+    return fs7.realpathSync.native(file);
   } catch {
     return file;
   }
 }
 function runnerConfigs(dir, stryker, options) {
-  const files = [path6.resolve(dir, stryker)];
+  const files = [path7.resolve(dir, stryker)];
   const named = options.testRunner === "vitest" ? options.vitestConfig : options.jestConfig;
   if (options.testRunner !== "vitest" && options.testRunner !== "jest") {
     throw new AffectedError(
@@ -2354,129 +3259,325 @@ function runnerConfigs(dir, stryker, options) {
     );
   }
   if (typeof named === "string") {
-    files.push(path6.resolve(dir, named));
+    files.push(path7.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)) {
+        const file = path7.join(dir, name + extension);
+        if (fs7.existsSync(file)) {
           files.push(file);
         }
       }
     }
   }
-  return { files: files.filter((file) => fs6.existsSync(file)).map(realpath) };
+  return {
+    files: files.filter((file) => fs7.existsSync(file)).map(realpath),
+    runner: options.testRunner,
+    checkers: Array.isArray(options.checkers) && options.checkers.length > 0
+  };
+}
+var CHECKS_TYPES = /\bcheckers\b|typescript-checker|\btypecheck\b/;
+var TS_JEST_STRIPS = /["']?(?:isolatedModules["']?\s*:\s*true|diagnostics["']?\s*:\s*false)/;
+var TS_JEST_UNSURE = /\b(?:projects|compilerOptions)\b|\btsconfig["']?\s*:\s*\{/;
+var STRIPPING_TRANSFORMS = /@swc\/jest|babel-jest|esbuild-jest|@sucrase\/jest/;
+var KEEPS_IMPORTS = /\b(?:verbatimModuleSyntax|preserveValueImports|importsNotUsedAsValues|onlyRemoveTypeImports)\b/;
+var COMPILER_CONFIG = /^(?:[jt]sconfig(?:\..+)?\.json|\.swcrc|\.babelrc(?:\..+)?|babel\.config\..+)$/;
+function typesErased(configs, texts, compiler) {
+  const all = texts.map(withoutComments).join("\n");
+  let erased = false;
+  if (configs.checkers !== true && !CHECKS_TYPES.test(all)) {
+    if (configs.runner === "vitest") {
+      erased = true;
+    } else if (configs.runner === "jest") {
+      erased = /\bts-jest\b/.test(all) ? TS_JEST_STRIPS.test(all) && !TS_JEST_UNSURE.test(all) : STRIPPING_TRANSFORMS.test(all) && !/\bpreset\b/.test(all);
+    }
+  }
+  const inline = erased && !KEEPS_IMPORTS.test(all) && compiler.some(({ file }) => /^tsconfig/.test(path7.basename(file))) && compiler.every(({ text }) => text !== null && !KEEPS_IMPORTS.test(text));
+  return { erased, inline };
+}
+function compilerConfigs(dir, root, keys) {
+  const above = /* @__PURE__ */ new Set();
+  for (let current = path7.dirname(dir); ; current = path7.dirname(current)) {
+    const relative = path7.relative(root, current);
+    if (relative.startsWith("..") || path7.isAbsolute(relative)) {
+      break;
+    }
+    above.add(current);
+    if (current === path7.dirname(current)) {
+      break;
+    }
+  }
+  const compared = new Set(keys.map((key) => path7.join(root, key)));
+  const starts = [...compared].filter(
+    (file) => (COMPILER_CONFIG.test(path7.basename(file)) || path7.basename(file) === "package.json") && (file.startsWith(`${dir}${path7.sep}`) || above.has(path7.dirname(file)))
+  );
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...starts];
+  for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+    if (seen.has(file)) {
+      continue;
+    }
+    seen.add(file);
+    let text = null;
+    if (compared.has(file) || file.split(path7.sep).includes("node_modules")) {
+      try {
+        text = fs7.readFileSync(file, "utf8");
+      } catch {
+        text = null;
+      }
+    }
+    found.push({ file, text });
+    for (const base of text === null ? [] : valuesOf(text, "extends")) {
+      queue.push(extended(base, file) ?? `${file} extends ${base}`);
+    }
+  }
+  return found;
+}
+function extended(base, from) {
+  const candidates = (start) => [
+    start,
+    `${start}.json`,
+    path7.join(start, "tsconfig.json")
+  ];
+  if (base.startsWith(".") || path7.isAbsolute(base)) {
+    return candidates(path7.resolve(path7.dirname(from), base)).find(isFile2) ?? null;
+  }
+  for (let current = path7.dirname(from); ; current = path7.dirname(current)) {
+    const file = candidates(path7.join(current, "node_modules", base)).find(isFile2);
+    if (file !== void 0) {
+      return file;
+    }
+    if (current === path7.dirname(current)) {
+      return null;
+    }
+  }
+}
+function isFile2(file) {
+  try {
+    return fs7.statSync(file).isFile();
+  } catch {
+    return false;
+  }
 }
 function fileEdges(file, context) {
-  const { dir, aliases, cache } = context;
+  const { dir, aliases, cache, types } = context;
   const known = cache.get(file);
   if (known !== void 0) {
     return known;
   }
-  const shown = (one) => toPosix2(path6.relative(dir, one));
+  const shown = (one) => toPosix2(path7.relative(dir, one));
   const target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFile(path6.resolve(path6.dirname(from), specifier));
+      return resolveFiles(path7.resolve(path7.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)));
+    return alias === void 0 ? [] : resolveFiles(path7.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
+  };
+  const found = { loads: [], unknown: null, loading: null, computed: false, unnamed: [] };
+  const loading = (reason) => {
+    found.unknown ??= reason;
+    found.loading ??= reason;
   };
-  const found = { loads: [], unknown: null, computed: false, unnamed: [] };
   cache.set(file, found);
-  const snapshotFile = path6.join(
-    path6.dirname(file),
+  const snapshotFile = path7.join(
+    path7.dirname(file),
     "__snapshots__",
-    `${path6.basename(file)}.snap`
+    `${path7.basename(file)}.snap`
   );
-  if (fs6.existsSync(snapshotFile)) {
+  if (fs7.existsSync(snapshotFile)) {
     found.loads.push(realpath(snapshotFile));
   }
+  const mocks = path7.join(path7.dirname(file), "__mocks__");
+  const name = path7.basename(file);
+  const candidates = isDirectory(mocks) ? [
+    path7.join(mocks, name),
+    ...resolveFiles(path7.join(mocks, name.replace(/\.[^.]+$/, "")), false, false)
+  ] : [];
+  for (const mock of new Set(candidates)) {
+    if (isFile2(mock)) {
+      found.loads.push(realpath(mock));
+    }
+  }
   if (!SCRIPT.test(file) && !COMPONENT.test(file)) {
     return found;
   }
-  const source = fs6.readFileSync(file, "utf8");
+  const source = fs7.readFileSync(file, "utf8");
+  const code = withoutComments(source);
   if (COMPONENT.test(file)) {
-    found.unknown = `${shown(file)} is a component, which can use others that it does not import`;
+    loading(`${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);
+  const uncheckable = findUncheckableImports(code)[0];
+  const runtime = RUNTIME_PATHS.exec(code);
+  const runtimeLoads = RUNTIME_LOADS.exec(code);
   if (uncheckable !== void 0) {
     found.unknown = `${shown(file)}:${uncheckable} imports a module whose path is not written out`;
+    found.loading = found.unknown;
     found.computed = true;
   } else if (runtime !== null) {
     found.unknown = `${shown(file)} uses ${runtime[0]}, which can reach files that no import names`;
+    if (runtimeLoads !== null) {
+      found.loading ??= `${shown(file)} uses ${runtimeLoads[0]}, which can reach files that no import names`;
+    }
   }
+  const location = LOCATION.exec(code);
+  const refs = parseImports(code);
+  const dropped = (ref) => types !== void 0 && types.erased && (ref.typeOnly || types.inline && ref.inlineTypes === true);
   const specifiers = /* @__PURE__ */ new Set([
-    ...parseImports(source).map((ref) => ref.module),
-    ...[...source.matchAll(RUNNER_LOAD)].map((match) => match[2])
+    ...refs.filter((ref) => !dropped(ref)).map((ref) => ref.module),
+    ...[...code.matchAll(RUNNER_LOAD)].map((match) => match[2])
   ]);
+  const typeLines = /* @__PURE__ */ new Map();
+  for (const ref of refs.filter(dropped)) {
+    const key = `${ref.line}:${ref.module}`;
+    typeLines.set(key, (typeLines.get(key) ?? 0) + 1);
+  }
   for (const specifier of specifiers) {
-    if (path6.isAbsolute(specifier) || specifier.startsWith("file:")) {
-      const resolved = resolveFile(
-        specifier.startsWith("file:") ? new URL(specifier).pathname : specifier
+    if (path7.isAbsolute(specifier) || specifier.startsWith("file:")) {
+      const resolved2 = resolveFiles(
+        withoutQuery(specifier.startsWith("file:") ? new URL(specifier).pathname : specifier)
       );
-      if (resolved === null) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+      if (resolved2.length === 0) {
+        loading(`${shown(file)} imports ${specifier}, which leads to no file`);
       } else {
-        found.loads.push(realpath(resolved));
+        found.loads.push(...resolved2.map(realpath));
       }
     } else if (isProjectImport(specifier, aliases)) {
-      const resolved = target(specifier, file);
-      if (resolved === null) {
-        found.unknown ??= `${shown(file)} imports ${specifier}, which leads to no file`;
+      const resolved2 = target(withoutQuery(specifier), file);
+      if (resolved2.length === 0) {
+        loading(`${shown(file)} imports ${specifier}, which leads to no file`);
       } else {
-        found.loads.push(realpath(resolved));
+        found.loads.push(...resolved2.map(realpath));
       }
     } else if (FILE_MODULES.has(bare(specifier))) {
-      found.unknown ??= `${shown(file)} imports ${specifier}, which can reach files that no import names`;
+      const reason = `${shown(file)} imports ${specifier}, which can reach files that no import names`;
+      if (LOADING_MODULES.has(bare(specifier))) {
+        loading(reason);
+      } else {
+        found.unknown ??= reason;
+      }
     } 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)`;
+        loading(
+          `${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`;
+        loading(
+          `${shown(file)} imports ${specifier}, a package of the repository linked into node_modules`
+        );
         found.computed = true;
       }
     }
   }
+  if (location !== null) {
+    const reads = LOCATION_READS.exec(code);
+    const reader = [...specifiers].find(
+      (specifier) => !specifier.startsWith(".") && !path7.isAbsolute(specifier) && !specifier.startsWith("file:") && !isProjectImport(specifier, aliases) && !LOCATION_SAFE.has(bare(specifier))
+    );
+    if (reads !== null) {
+      found.unknown ??= `${shown(file)} uses ${location[0]} and ${reads[0].replace(/\(\s*$/, "")}, which can reach files that no import names`;
+      const loads = LOCATION_LOADS.exec(code);
+      if (loads !== null) {
+        found.loading ??= `${shown(file)} uses ${location[0]} and ${loads[0].replace(/\(\s*$/, "")}, which can reach files that no import names`;
+      }
+    } else if (reader !== void 0) {
+      found.unknown ??= `${shown(file)} uses ${location[0]} and imports ${reader}, which can read files by it that no import names`;
+    }
+  }
+  let line = 1;
+  let counted = 0;
   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));
+    for (; counted < match.index; counted += 1) {
+      if (source[counted] === "\n") {
+        line += 1;
       }
     }
+    const text = match[2];
+    const key = `${line}:${text}`;
+    const left = typeLines.get(key) ?? 0;
+    if (left > 0) {
+      typeLines.set(key, left - 1);
+    } else if (text.startsWith(".") && !specifiers.has(text)) {
+      found.loads.push(...resolveFiles(path7.resolve(path7.dirname(file), text)).map(realpath));
+    } else if (PATH_FROM_TOP.test(text) && isFile2(path7.resolve(dir, text))) {
+      found.loads.push(realpath(path7.resolve(dir, text)));
+    }
   }
   return found;
 }
 function affectedInputs(manifest, input) {
+  return resolving(() => inputsOf(manifest, input));
+}
+function inputsOf(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(".."));
+  const absolute = placed.find((file) => path7.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)) {
+    const relative = path7.relative(input.root, realpath(file));
+    if (relative.startsWith("..") || path7.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 shown = (file) => toPosix2(path7.relative(dir, file));
+  const plain2 = /* @__PURE__ */ new Map();
+  const configTexts = [];
+  const runnerSources = [];
+  const reached = new Set(input.configs.files);
+  const pending = [...input.configs.files];
+  for (let file = pending.shift(); file !== void 0; file = pending.shift()) {
+    const text = fs7.readFileSync(file, "utf8");
+    configTexts.push(text);
+    runnerSources.push({ file, text });
+    for (const next of fileEdges(file, { dir, aliases, cache: plain2 }).loads) {
+      if (!reached.has(next) && SCRIPT.test(next)) {
+        reached.add(next);
+        pending.push(next);
+      }
+    }
+  }
+  const compiler = compilerConfigs(dir, realpath(input.root), Object.keys(input.files));
+  const types = typesErased(input.configs, configTexts, compiler);
+  const maps = unexplainedMaps({
+    dir,
+    aliases,
+    // Not what lies outside of the compared files: this package, imported by path, is installed.
+    runner: [
+      ...runnerSources.filter(({ file }) => {
+        const relative = path7.relative(input.root, realpath(file));
+        return !relative.startsWith("..") && toPosix2(relative) in input.files;
+      }),
+      ...jestInPackage(dir, input.configs)
+    ],
+    compiler,
+    ...input.configs.runner === void 0 ? {} : { testRunner: input.configs.runner }
+  });
+  if (maps !== null) {
+    throw new AffectedError(maps);
+  }
   const edges = /* @__PURE__ */ new Map();
-  const edgesOf = (file) => fileEdges(file, { dir, aliases, cache: edges });
+  const edgesOf = (file) => fileEdges(file, { dir, aliases, cache: edges, types });
+  const blind = /* @__PURE__ */ Object.create(null);
   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) {
+      if (strict === "every" && found.unknown !== null) {
         throw new AffectedError(found.unknown);
       }
+      if (strict === "gate" && found.unknown !== null) {
+        if (found.loading !== null) {
+          throw new AffectedError(found.loading);
+        }
+        blind[keyOf2(file)] = found.unknown;
+      }
       for (const next of found.loads) {
         if (!seen.has(next)) {
           seen.add(next);
@@ -2487,8 +3588,8 @@ function affectedInputs(manifest, input) {
     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 relative = path7.relative(input.root, realpath(file));
+    return !relative.startsWith("..") && !path7.isAbsolute(relative) && toPosix2(relative) in input.files;
   };
   const keysOf = (files) => files.map((file) => {
     const key = keyOf2(file);
@@ -2507,17 +3608,25 @@ function affectedInputs(manifest, input) {
       if (!SCRIPT.test(loaded)) {
         continue;
       }
-      for (const match of fs6.readFileSync(loaded, "utf8").matchAll(QUOTED)) {
+      for (const match of fs7.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 here = resolveFiles(path7.resolve(path7.dirname(loaded), text), false, false);
+        const candidates = here.length > 0 ? here : resolveFiles(path7.resolve(dir, text), false, false);
+        for (const found of candidates) {
+          if (text.includes("*") || !isCompared(found)) {
+            continue;
+          }
+          if (SCRIPT.test(found)) {
+            named.push(realpath(found));
+          } else {
+            config.add(realpath(found));
+          }
         }
       }
     }
   }
   const gatePaths = new Map(
-    manifest.gates.map((gate) => [realpath(path6.join(dir, gate.path)), gate.path])
+    manifest.gates.map((gate) => [realpath(path7.join(dir, gate.path)), gate.path])
   );
   const tests = [
     .../* @__PURE__ */ new Set([
@@ -2528,13 +3637,13 @@ function affectedInputs(manifest, input) {
   ];
   const runAsSuch = new Set(
     [...tests, ...manifest.gates.map((gate) => gate.path)].map(
-      (file) => realpath(path6.join(dir, file))
+      (file) => realpath(path7.join(dir, file))
     )
   );
-  const subprojectKey = toPosix2(path6.relative(input.root, dir));
+  const subprojectKey = toPosix2(path7.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)) {
+    for (const loaded of closure(file, "every")) {
       const gate = gatePaths.get(loaded);
       if (gate !== void 0) {
         throw new AffectedError(
@@ -2544,16 +3653,16 @@ function affectedInputs(manifest, input) {
       config.add(loaded);
     }
   }
-  const fromSubproject = (file) => path6.join(dir, file);
+  const fromSubproject = (file) => path7.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)) {
+    if (!fs7.existsSync(absolute2)) {
       continue;
     }
-    closures[keysOf([absolute2])[0]] = keysOf(closure(realpath(absolute2), true));
+    closures[keysOf([absolute2])[0]] = keysOf(closure(realpath(absolute2), "gate"));
   }
-  const keyed = (files) => files.map((file) => toPosix2(path6.relative(input.root, path6.join(dir, file))));
+  const keyed = (files) => files.map((file) => toPosix2(path7.relative(input.root, path7.join(dir, file))));
   const dependencies = gateDependencies({
     gates: manifest.gates.map((gate) => ({
       key: keyed([gate.path])[0],
@@ -2563,9 +3672,10 @@ function affectedInputs(manifest, input) {
     covering: Object.fromEntries(
       Object.entries(input.covering).map(([gate, specs]) => [keyed([gate])[0], keyed(specs)])
     ),
-    closures
+    closures,
+    blind
   });
-  const subproject = toPosix2(path6.relative(input.root, dir));
+  const subproject = toPosix2(path7.relative(input.root, dir));
   const prefix = subproject === "" ? "" : `${subproject}/`;
   const gates = /* @__PURE__ */ Object.create(null);
   for (const gate of manifest.gates) {
@@ -2576,10 +3686,26 @@ function affectedInputs(manifest, input) {
       specs: found.specs.map(
         (spec) => spec.startsWith(prefix) ? spec.slice(prefix.length) : spec
       ),
-      files: found.files
+      files: found.files,
+      ...found.blind === void 0 ? {} : { blind: found.blind }
     };
   }
-  return { subproject, config: keysOf([...config]).sort(), gates };
+  const packageMocks = Object.keys(input.files).filter(
+    (key) => isNestedMock(key, subproject) && mockNames(key).some(
+      (name) => builtinModules2.includes(name) || installed(name, path7.join(input.root, key))
+    )
+  );
+  return {
+    subproject,
+    config: [.../* @__PURE__ */ new Set([...keysOf([...config]), ...packageMocks])].sort(),
+    gates
+  };
+}
+function mockNames(key) {
+  const segments = key.replace(/\.[^./]+$/, "").split("/");
+  return segments.flatMap(
+    (segment, index) => segment === "__mocks__" && index < segments.length - 1 ? [segments.slice(index + 1).join("/")] : []
+  );
 }
 var NOT_THE_HELPER2 = "the runner config is not made with createJestGatesConfig or createVitestGatesConfig";
 var OWN = /@t09tanaka\/test-gates\/(?:jest|vitest)\b/;
@@ -2615,11 +3741,14 @@ var READ_BY_NAME = [
   /^\.swcrc$/
 ];
 function loadedScope(manifest, configs, listed2) {
+  return resolving(() => scopeOf(manifest, configs, listed2));
+}
+function scopeOf(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")));
+  const texts = runner.map((file) => withoutComments(fs7.readFileSync(file, "utf8")));
   if (runner.length === 0 || !texts.every((text) => OWN.test(text))) {
     return { every: NOT_THE_HELPER2 };
   }
@@ -2634,21 +3763,21 @@ function loadedScope(manifest, configs, listed2) {
       fileEdges(file, context).loads.forEach((loaded) => parts.add(loaded));
     }
   }
-  if ([...parts].some((file) => PROJECTS.test(withoutComments(fs6.readFileSync(file, "utf8"))))) {
+  if ([...parts].some((file) => PROJECTS.test(withoutComments(fs7.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 named = fs7.readdirSync(dir).filter((name) => READ_BY_NAME.some((pattern) => pattern.test(name))).map((name) => path7.join(dir, name));
+  const mocks = path7.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);
+    ...manifest.gates.flatMap((gate) => [gate.path, ...gate.existingSpecs]).map((file) => path7.join(dir, file)),
+    ...listed2.filter((file) => file.startsWith(`${mocks}${path7.sep}`))
+  ].filter((file) => fs7.existsSync(file)).map(realpath);
   const naming = new Set(
-    [...configs.files, ...named].filter((file) => fs6.existsSync(file)).map(realpath)
+    [...configs.files, ...named].filter((file) => fs7.existsSync(file)).map(realpath)
   );
   const seen = new Set(seeds);
   const queue = [...seeds];
@@ -2660,7 +3789,7 @@ function loadedScope(manifest, configs, listed2) {
     }
   };
   for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
-    if (fs6.statSync(file).isDirectory()) {
+    if (fs7.statSync(file).isDirectory()) {
       continue;
     }
     const edges = fileEdges(file, context);
@@ -2671,19 +3800,16 @@ function loadedScope(manifest, configs, listed2) {
     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) {
+    if (naming.has(file) || SCRIPT.test(file) && path7.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));
+        const here = resolveFiles(path7.resolve(path7.dirname(file), text), false);
+        const found = here.length > 0 ? here : resolveFiles(path7.resolve(dir, text), false);
+        for (const one of text.includes("*") ? [] : found) {
+          if (!SCRIPT.test(one)) {
+            naming.add(realpath(one));
           }
-          add(found);
+          add(one);
         }
       }
     }
@@ -2702,7 +3828,7 @@ function endingAs(specifier, files) {
   });
 }
 function namedIn(file) {
-  const text = fs6.readFileSync(file, "utf8");
+  const text = fs7.readFileSync(file, "utf8");
   if (SCRIPT.test(file)) {
     return [...text.matchAll(QUOTED)].map((match) => match[2]);
   }
@@ -2740,298 +3866,475 @@ function valuesOf(text, key) {
   return found;
 }
 function withoutComments(text) {
-  let out = "";
+  const out = [];
+  const before = { last: "", word: "" };
+  let space = false;
+  const keep = (part) => {
+    out.push(part);
+    for (const one of part) {
+      if (/\s/.test(one)) {
+        space = true;
+        continue;
+      }
+      const word = /[\w$]/.test(one);
+      before.word = !word ? "" : space || !/[\w$]/.test(before.last) ? one : before.word + one;
+      before.last = one;
+      space = false;
+    }
+  };
   for (let at = 0; at < text.length; at += 1) {
     const char = text[at];
+    const next = text[at + 1];
     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);
+      const end = stringEnd(text, at);
+      keep(text.slice(at, end + 1));
       at = end;
-    } else if (char === "/" && text[at + 1] === "/") {
+    } else if (char === "/" && next === "/" && !SCHEME.test(text.slice(Math.max(0, at - 40), at))) {
       const end = text.indexOf("\n", at);
       at = end === -1 ? text.length : end - 1;
-    } else if (char === "/" && text[at + 1] === "*") {
+    } else if (char === "/" && next === "*") {
       const end = text.indexOf("*/", at + 2);
-      at = end === -1 ? text.length : end + 1;
+      const stop = end === -1 ? text.length : end + 2;
+      keep(` ${text.slice(at, stop).replace(/[^\n]/g, "")}`);
+      at = stop - 1;
+    } else if (char === "/" && next !== "/") {
+      const end = patternEnd(text, at, mayStartPattern(before));
+      keep(text.slice(at, end + 1));
+      at = end;
+    } else {
+      keep(char);
+    }
+  }
+  return out.join("");
+}
+var SCHEME = /(?:^|[^\w$.+-])[A-Za-z][\w+.-]*:$/;
+function patternEnd(text, at, pattern) {
+  let inClass = false;
+  let end = at + 1;
+  for (; end < text.length && text[end] !== "\n"; end += 1) {
+    const char = text[end];
+    if (char === "\\") {
+      end += 1;
+    } else if (char === "[") {
+      inClass = true;
+    } else if (char === "]") {
+      inClass = false;
+    } else if (char === "/" && !inClass) {
+      const comment = text[end + 1] === "/" || text[end + 1] === "*";
+      return pattern || !comment ? end : at;
+    } else if (!pattern && (char === "'" || char === '"' || char === "`")) {
+      return at;
+    }
+  }
+  return pattern ? end : at;
+}
+function stringEnd(text, at) {
+  const quote = text[at];
+  let end = at + 1;
+  while (end < text.length && text[end] !== quote && (quote === "`" || text[end] !== "\n")) {
+    if (text[end] === "\\") {
+      end += 2;
+    } else if (quote === "`" && text.startsWith("${", end)) {
+      end = placeholderEnd(text, end + 2) + 1;
     } else {
-      out += char;
+      end += 1;
     }
   }
-  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"]);
-var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
-var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
-function normalizeCode(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function normalizePath(file) {
-  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+  return end;
 }
-function normalizeNewlines(text) {
-  return text.replace(/\r\n/g, "\n");
+function placeholderEnd(text, at) {
+  let depth = 0;
+  for (let index = at; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "'" || char === '"' || char === "`") {
+      index = stringEnd(text, index);
+    } else if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      if (depth === 0) {
+        return index;
+      }
+      depth -= 1;
+    }
+  }
+  return text.length;
+}
+var BEFORE_PATTERN = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function mayStartPattern(before) {
+  if (before.word !== "") {
+    return BEFORE_PATTERN.has(before.word);
+  }
+  return before.last === "" || !")]".includes(before.last);
+}
+function jestInPackage(dir, configs) {
+  const file = path7.join(dir, "package.json");
+  return configs.runner === "jest" && configs.files.length === 1 && fs7.existsSync(file) ? [{ file, text: fs7.readFileSync(file, "utf8"), mapperOnly: true }] : [];
+}
+var STRING_LITERAL = String.raw`'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"`;
+function stringValue(text) {
+  const match = new RegExp(`^\\s*(${STRING_LITERAL})\\s*$`).exec(text);
+  return match === null ? null : match[1].slice(1, -1).replace(/\\(.)/g, "$1");
+}
+function partsOf2(text, at) {
+  const parts = [];
+  let depth = 0;
+  let start = at + 1;
+  for (let index = at; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "'" || char === '"' || char === "`") {
+      let end = index + 1;
+      while (end < text.length && text[end] !== char) {
+        end += text[end] === "\\" ? 2 : 1;
+      }
+      index = end;
+    } else if ("{[(".includes(char)) {
+      depth += 1;
+    } else if ("}])".includes(char)) {
+      depth -= 1;
+      if (depth === 0) {
+        parts.push(text.slice(start, index));
+        return { parts: parts.filter((part) => part.trim() !== ""), end: index };
+      }
+    } else if (char === "," && depth === 1) {
+      parts.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  return null;
 }
-function sliceByLocation(source, location) {
-  const lines = source.split("\n");
-  const { start, end } = location;
-  const first = lines[start.line - 1];
-  const last = lines[end.line - 1];
-  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+function property(part) {
+  const match = new RegExp(`^\\s*(${STRING_LITERAL}|[\\w$]+)\\s*:([\\s\\S]*)$`).exec(part);
+  if (match === null) {
     return null;
   }
-  if (start.line === end.line) {
-    return first.slice(start.column - 1, end.column - 1);
+  const key = match[1];
+  return { key: stringValue(key) ?? key, value: match[2].trim() };
+}
+function aliasPath(expression, file, text, depth = 0) {
+  const value = expression.trim();
+  const here = path7.dirname(file);
+  if (value === "__dirname" || value === "import.meta.dirname" || /^(?:path\.)?dirname\(\s*(?:url\.)?fileURLToPath\(\s*import\.meta\.url\s*\)\s*\)$/.test(value)) {
+    return here;
+  }
+  const url = new RegExp(
+    `^(?:(?:url\\.)?fileURLToPath\\(\\s*new URL\\(\\s*(${STRING_LITERAL})\\s*,\\s*import\\.meta\\.url\\s*\\)\\s*\\)|new URL\\(\\s*(${STRING_LITERAL})\\s*,\\s*import\\.meta\\.url\\s*\\)\\.pathname)$`
+  ).exec(value);
+  if (url !== null) {
+    return path7.resolve(here, stringValue(url[1] ?? url[2]));
+  }
+  const call = /^(?:path\.)?(?:resolve|join)\s*\(/.exec(value);
+  if (call !== null) {
+    const found = partsOf2(value, call[0].length - 1);
+    if (found === null || value.slice(found.end + 1).trim() !== "" || found.parts.length === 0) {
+      return null;
+    }
+    const [first, ...rest] = found.parts;
+    const base = aliasPath(first, file, text, depth + 1);
+    const parts = rest.map(stringValue);
+    return base === null || parts.some((part) => part === null) ? null : path7.resolve(base, ...parts);
   }
-  return [
-    first.slice(start.column - 1),
-    ...lines.slice(start.line, end.line - 1),
-    last.slice(0, end.column - 1)
-  ].join("\n");
+  if (/^[A-Za-z_$][\w$]*$/.test(value) && depth < 4) {
+    const declarations = text.match(
+      new RegExp(`\\b(?:const|let|var|function|class)\\s+${value.replace(/\$/g, "\\$")}\\b`, "g")
+    );
+    const bound = new RegExp(`\\bconst\\s+${value.replace(/\$/g, "\\$")}\\s*=\\s*([^;\\n]+)`).exec(
+      text
+    );
+    return declarations?.length === 1 && bound !== null ? aliasPath(bound[1], file, text, depth + 1) : null;
+  }
+  return null;
 }
-function keyOf(mutator, original, replacement) {
-  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+var PACKAGE_NAME = /^(?:@[\w-][\w.-]*\/)?[\w-][\w.-]*$/;
+function isDirectory(file) {
+  try {
+    return fs7.statSync(file).isDirectory();
+  } catch {
+    return false;
+  }
 }
-function describeMutant(file, entry) {
-  const { mutant } = entry;
-  return {
-    file,
-    line: mutant.location.start.line,
-    column: mutant.location.start.column,
-    status: mutant.status,
-    mutator: mutant.mutatorName,
-    original: normalizeCode(entry.original),
-    replacement: normalizeCode(entry.replacement),
-    occurrence: entry.occurrence,
-    sameKeyCount: entry.sameKeyCount,
-    allowance: {
-      mutator: mutant.mutatorName,
-      original: normalizeCode(entry.original),
-      replacement: normalizeCode(entry.replacement),
-      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
-      reason: ""
-    }
-  };
+function regexPrefix(literal) {
+  const match = /^\/\^((?:[\w@~#%-]|\\[./@~#-])*)\\\/\/$/.exec(literal.trim());
+  return match === null ? null : `${match[1].replace(/\\(.)/g, "$1")}/`;
 }
-function describeAllowance(entry) {
-  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
-  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+function mapperPrefix(pattern) {
+  const match = /^\^((?:[\w@~#%/-]|\\[./@~#-])*)\(\.\*\)\$?$/.exec(pattern);
+  return match === null ? null : match[1].replace(/\\(.)/g, "$1");
 }
-function judgeMutationReport(input) {
-  const violations = [];
-  const survivors = [];
-  const unexpectedTimeouts = [];
-  const summary = {
-    total: 0,
-    detected: 0,
-    timeout: 0,
-    allowed: 0,
-    notEvaluable: 0,
-    unallowed: 0,
-    expectedTimeout: 0
-  };
-  const files = /* @__PURE__ */ new Map();
-  for (const [file, result] of Object.entries(input.report.files ?? {})) {
-    files.set(normalizePath(file), result);
-  }
-  for (const gate of input.gates) {
-    const gatePath = normalizePath(gate.path);
-    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
-    violations.push(...shapeViolations);
-    violations.push(
-      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
-    );
-    const result = files.get(gatePath);
-    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
-      violations.push({
-        file: gate.path,
-        message: "no mutants in the report (the gate was not mutation tested)"
-      });
-      continue;
-    }
-    const diskSource = input.readSource(gate.path);
-    const source = result.source ?? diskSource;
-    if (source === void 0) {
-      violations.push({
-        file: gate.path,
-        message: "source is neither in the report nor readable on disk"
-      });
-      continue;
-    }
-    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
-      violations.push({
-        file: gate.path,
-        message: "the report was made from a different version of this file. Run Stryker again"
-      });
-      continue;
-    }
-    const located = [];
-    const byKey = /* @__PURE__ */ new Map();
-    const sorted2 = [...result.mutants].sort(
-      (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
-    );
-    let locationsValid = true;
-    for (const mutant of sorted2) {
-      const original = sliceByLocation(normalizeNewlines(source), mutant.location);
-      if (original === null) {
-        violations.push({
-          file: gate.path,
-          line: mutant.location.start.line,
-          message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
-        });
-        locationsValid = false;
-        continue;
-      }
-      const replacement = mutant.replacement ?? "";
-      const key = keyOf(mutant.mutatorName, original, replacement);
-      const group = byKey.get(key) ?? [];
-      const entry = {
-        mutant,
-        original,
-        replacement,
-        occurrence: group.length + 1,
-        sameKeyCount: 0
-      };
-      group.push(entry);
-      byKey.set(key, group);
-      located.push(entry);
-    }
-    for (const group of byKey.values()) {
-      for (const entry of group) {
-        entry.sameKeyCount = group.length;
-      }
-    }
-    if (!locationsValid) {
-      continue;
+var ROOT_DIR_HERE = /* @__PURE__ */ new Set([
+  "__dirname",
+  "import.meta.dirname",
+  "import.meta.url",
+  "'.'",
+  '"."',
+  "'./'",
+  '"./"'
+]);
+function unexplainedMaps(input) {
+  const { dir, aliases } = input;
+  const reasons = [];
+  const mapped = [];
+  const shown = (file) => toPosix2(path7.relative(dir, file));
+  const under = (base, rest) => rest === "" ? `${base}/` : path7.join(base, rest);
+  const named = (prefix, target) => {
+    const alias = aliases.find((candidate) => prefix.startsWith(candidate.prefix));
+    if (alias === void 0) {
+      return false;
     }
-    const claim = (field, entries, noun, accept) => {
-      const claimed = /* @__PURE__ */ new Set();
-      if (!Array.isArray(entries)) {
-        return claimed;
-      }
-      entries.forEach((entry, index) => {
-        if (!isUsableEquivalentMutant(entry)) {
-          return;
-        }
-        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
-        const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
-        if (entry.occurrence === void 0 && group.length > 1) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
-          });
-          return;
+    const full = alias.target + prefix.slice(alias.prefix.length);
+    const slash = full === "" || full.endsWith("/");
+    return path7.resolve(dir, full) === path7.resolve(target) && slash === target.endsWith("/");
+  };
+  const advice = (prefix, target) => {
+    const relative = toPosix2(path7.relative(dir, target));
+    const shownTarget = relative === "" ? "./" : `${relative}/`;
+    const shorter = aliases.find((alias) => prefix.startsWith(alias.prefix));
+    const before = shorter === void 0 ? "" : shorter.prefix === prefix ? `, in place of the alias of ${prefix}` : `, before the alias of ${shorter.prefix}`;
+    return ` (add { "prefix": "${prefix}", "target": "${shownTarget}" } to settings.importAliases${before})`;
+  };
+  const missing = (file, key, word, prefix, target) => `${shown(file)} maps ${key} with ${word} in a way settings.importAliases does not name` + (prefix !== void 0 && target !== void 0 && isDirectory(target) ? advice(prefix, target) : "");
+  for (const { file, text: raw, mapperOnly } of input.runner) {
+    let viteAlias2 = function(part, list) {
+      let key = null;
+      let prefix = null;
+      let to = null;
+      if (list) {
+        const object = /^\s*\{/.test(part) ? partsOf2(part, part.indexOf("{")) : null;
+        const fields = Object.fromEntries(
+          (object?.parts ?? []).map(property).map((one) => [one?.key ?? "", one?.value ?? ""])
+        );
+        if (object === null || Object.keys(fields).sort().join() !== "find,replacement" || part.slice(object.end + 1).trim() !== "") {
+          return unreadableAlias2();
         }
-        const target = group[(entry.occurrence ?? 1) - 1];
-        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
-        if (!target || refusal !== null) {
-          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
-          return;
+        const find = fields.find;
+        const replacement = fields.replacement;
+        key = stringValue(find);
+        if (key !== null) {
+          prefix = key.endsWith("/") ? null : `${key}/`;
+          const target = aliasPath(replacement, file, text);
+          to = target === null ? null : `${target}/`;
+        } else {
+          key = find.trim();
+          prefix = regexPrefix(find);
+          const slashed = new RegExp(`^([\\s\\S]+?)\\s*\\+\\s*(?:'/'|"/")$`).exec(replacement);
+          const target = slashed === null ? null : aliasPath(slashed[1], file, text);
+          to = target === null ? null : `${target}/`;
+          if (prefix === null && to === null) {
+            return unreadableAlias2();
+          }
         }
-        if (claimed.has(target)) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: another ${noun} already covers this mutant`
-          });
-          return;
+      } else {
+        const entry = property(part);
+        if (entry === null) {
+          return unreadableAlias2();
         }
-        claimed.add(target);
-      });
-      return claimed;
+        key = entry.key;
+        prefix = key.endsWith("/") ? null : `${key}/`;
+        const target = aliasPath(entry.value, file, text);
+        to = target === null ? null : `${target}/`;
+      }
+      if (prefix === null || to === null || PACKAGE_NAME.test(key) && installed(key, file)) {
+        return missing(file, key, "alias");
+      }
+      if (!named(prefix, to)) {
+        return missing(file, key, "alias", prefix, to);
+      }
+      mapped.push(prefix);
+      return null;
+    }, unreadableAlias2 = function() {
+      return `${shown(file)} names alias in a way that cannot be read as a list of aliases`;
     };
-    const allowed = claim(
-      "equivalentMutants",
-      gate.equivalentMutants,
-      "allowance",
-      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
-    );
-    const expected = claim(
-      "expectedTimeouts",
-      gate.expectedTimeouts,
-      "entry",
-      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
-    );
-    for (const entry of located) {
-      const { mutant } = entry;
-      summary.total += 1;
-      if (DETECTED.has(mutant.status)) {
-        summary.detected += 1;
-        if (mutant.status === "Timeout") {
-          summary.timeout += 1;
-          if (expected.has(entry)) {
-            summary.expectedTimeout += 1;
-          } else {
-            unexpectedTimeouts.push(describeMutant(gate.path, entry));
+    var viteAlias = viteAlias2, unreadableAlias = unreadableAlias2;
+    const text = withoutComments(raw);
+    const words = mapperOnly === true ? /\bmoduleNameMapper\b/g : /\b(?:alias|moduleNameMapper)\b/g;
+    for (const match of text.matchAll(words)) {
+      const word = match[0];
+      const opening = /^['"]?\s*:\s*/.exec(text.slice(match.index + word.length));
+      const at = opening === null ? -1 : match.index + word.length + opening[0].length;
+      const found = at === -1 ? null : partsOf2(text, at);
+      const unreadable = `${shown(file)} names ${word} in a way that cannot be read as a list of aliases`;
+      if (found === null || text[at] !== "{" && !(word === "alias" && text[at] === "[")) {
+        reasons.push(unreadable);
+        continue;
+      }
+      for (const part of found.parts) {
+        if (word === "alias") {
+          const reason = viteAlias2(part, text[at] === "[");
+          if (reason !== null) {
+            reasons.push(reason);
           }
+          continue;
         }
-      } else if (NOT_EVALUABLE.has(mutant.status)) {
-        summary.notEvaluable += 1;
-      } else if (SURVIVED.has(mutant.status)) {
-        if (allowed.has(entry)) {
-          summary.allowed += 1;
+        const entry = property(part);
+        if (entry === null) {
+          reasons.push(unreadable);
           continue;
         }
-        summary.unallowed += 1;
-        survivors.push(describeMutant(gate.path, entry));
-      } else {
-        violations.push({
-          file: gate.path,
-          line: mutant.location.start.line,
-          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
-        });
+        const value = stringValue(entry.value);
+        const root = [...text.matchAll(/\brootDir\b['"]?\s*:\s*([^,}\n]+)/g)].map((one) => one[1].trim()).find((set) => !ROOT_DIR_HERE.has(set));
+        if (root !== void 0 && (value === null || value.includes("<rootDir>"))) {
+          reasons.push(`${shown(file)} sets rootDir to a directory that cannot be told: ${root}`);
+          continue;
+        }
+        if (value !== null && !value.includes("$")) {
+          continue;
+        }
+        const prefix = mapperPrefix(entry.key);
+        const target = value === null ? null : /^<rootDir>\/(.*)\$1$/.exec(value);
+        const to = target === null ? null : under(path7.dirname(file), target[1]);
+        if (prefix === null || to === null) {
+          reasons.push(missing(file, entry.key, word));
+        } else if (!named(prefix, to)) {
+          reasons.push(missing(file, entry.key, word, prefix, to));
+        } else {
+          mapped.push(prefix);
+        }
       }
     }
   }
-  if (summary.total === 0) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: "no mutants were evaluated (the mutation test ran on nothing)"
-    });
-  }
-  const maxTimeouts = input.maxTimeouts ?? 0;
-  if (unexpectedTimeouts.length > maxTimeouts) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
-    });
+  const tsconfigs = input.compiler.filter(({ file }) => /^[jt]sconfig/.test(path7.basename(file)));
+  const withBase = tsconfigs.filter(({ text }) => text !== null && /"baseUrl"\s*:/.test(text));
+  for (const { file, text } of input.compiler) {
+    if (text === null) {
+      continue;
+    }
+    const plain2 = withoutComments(text);
+    const name = path7.basename(file);
+    const swc = name === ".swcrc";
+    if (!/^[jt]sconfig/.test(name) && !swc) {
+      const babel = /"babel"\s*:\s*/.exec(plain2);
+      const own2 = name !== "package.json" ? plain2 : babel === null ? "" : (() => {
+        const found2 = partsOf2(plain2, babel.index + babel[0].length);
+        return found2 === null ? plain2 : found2.parts.join(",");
+      })();
+      const maps = /module-resolver|\balias\b/.exec(own2);
+      if (maps !== null) {
+        reasons.push(`${shown(file)} maps modules (${maps[0]}), which cannot be told`);
+      }
+      continue;
+    }
+    const paths = /"paths"\s*:\s*/.exec(plain2);
+    if (paths === null || !swc && input.testRunner === "jest") {
+      continue;
+    }
+    const at = paths.index + paths[0].length;
+    const found = plain2[at] === "{" ? partsOf2(plain2, at) : null;
+    if (found === null) {
+      reasons.push(`${shown(file)} names paths in a way that cannot be read as a list of aliases`);
+      continue;
+    }
+    const own = /"baseUrl"\s*:\s*"([^"]*)"/.exec(plain2);
+    if (own === null && !swc && withBase.length > 0) {
+      reasons.push(`${shown(file)} names paths, and baseUrl is set in another file`);
+      continue;
+    }
+    const base = path7.resolve(path7.dirname(file), own?.[1] ?? ".");
+    for (const part of found.parts) {
+      const entry = property(part);
+      if (entry === null) {
+        reasons.push(
+          `${shown(file)} names paths in a way that cannot be read as a list of aliases`
+        );
+        continue;
+      }
+      const list = entry.value.startsWith("[") ? partsOf2(entry.value, 0) : null;
+      const target = list?.parts.length === 1 ? stringValue(list.parts[0]) : null;
+      const prefix = entry.key.endsWith("*") ? entry.key.slice(0, -1) : null;
+      if (prefix === null && target !== null && !target.includes("*") && path7.resolve(base, target).split(path7.sep).includes("node_modules")) {
+        continue;
+      }
+      const directory = target?.endsWith("*") ? target.slice(0, -1) : null;
+      if (!swc && prefix !== null && mapped.some((one) => prefix.startsWith(one))) {
+        continue;
+      }
+      if (prefix === null || directory === null) {
+        reasons.push(missing(file, entry.key, "paths"));
+      } else if (!named(prefix, under(base, directory))) {
+        reasons.push(missing(file, entry.key, "paths", prefix, under(base, directory)));
+      }
+    }
   }
-  return { violations, survivors, unexpectedTimeouts, summary };
+  return reasons.length === 0 ? null : [...new Set(reasons)].join("; ");
 }
-function formatSurvivor(survivor) {
-  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
-  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+
+// src/commands/mutation.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import fs10 from "fs";
+import path10 from "path";
+import { pathToFileURL } from "url";
+
+// src/main-worktree.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import fs8 from "fs";
+import path8 from "path";
+function git2(dir, args) {
+  const result = spawnSync3("git", args, {
+    cwd: dir,
+    env: gitEnvironment(process.env),
+    encoding: "utf8"
+  });
+  return result.error || result.status !== 0 ? null : result.stdout.trim().split("\n");
+}
+function linkedWorktreeOf(dir) {
+  const found = git2(dir, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-dir",
+    "--git-common-dir"
+  ]);
+  if (found === null || found.length !== 3) {
+    return null;
+  }
+  const [top, gitDir, common] = found;
+  if (gitDir === common || path8.basename(common) !== ".git") {
+    return null;
+  }
+  try {
+    const main2 = fs8.realpathSync(path8.dirname(common));
+    const real = fs8.realpathSync(top);
+    return main2 === real ? null : { top: real, main: main2 };
+  } catch {
+    return null;
+  }
 }
-function formatSummary(summary) {
-  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+function inMainWorktree(linked, file) {
+  const relative = path8.relative(linked.top, file);
+  if (relative === "" || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    return null;
+  }
+  return path8.join(linked.main, relative);
 }
 
 // src/commands/mutation-result.ts
+import fs9 from "fs";
+import path9 from "path";
 function reportPathOf(manifest, override) {
-  return path7.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+  return path9.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
 }
-function runMutationResult(dir, reportOverride, io2, only = [], seen = () => void 0) {
+function runMutationResult(dir, reportOverride, io2, only = [], seen = () => void 0, retried = null) {
   const manifest = readManifest(dir);
   const gates = only.length === 0 ? manifest.gates : manifest.gates.filter((gate) => only.includes(gate.path));
   const caveat = only.length === 0 ? "" : gateRunCaveat(gates.length, manifest.gates.length);
   const reportPath = reportPathOf(manifest, reportOverride);
-  const shown = path7.relative(manifest.dir, reportPath) || reportPath;
+  const shown = path9.relative(manifest.dir, reportPath) || reportPath;
   let report;
   try {
-    report = JSON.parse(fs7.readFileSync(reportPath, "utf8"));
+    report = JSON.parse(fs9.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?`
@@ -3048,7 +4351,7 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
     maxTimeouts: manifest.settings.maxTimeouts,
     readSource: (gatePath) => {
       try {
-        return fs7.readFileSync(path7.join(manifest.dir, gatePath), "utf8");
+        return fs9.readFileSync(path9.join(manifest.dir, gatePath), "utf8");
       } catch {
         return void 0;
       }
@@ -3096,8 +4399,34 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
       io2.err(`  - ${formatSurvivor(mutant)}`);
     }
     io2.err("");
-    io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
-    io2.err("can time out instead. Run again with less load (-- --concurrency 1). Only for a");
+    if (retried === null || retried === "failed") {
+      io2.err("A timeout counts as detected, but on a loaded machine a mutant that would survive");
+      if (retried === null) {
+        io2.err(
+          "can time out instead. `test-gates mutation` runs such timeouts again one at a time"
+        );
+        io2.err("(--concurrency 1) before it fails; these were not run again. Only for a");
+      } else {
+        io2.err(
+          "can time out instead. They were run again one at a time (--concurrency 1), but that"
+        );
+        io2.err("run gave no result (see above), so these are those of the first run. Only for a");
+      }
+    } else if (retried.missing === 0) {
+      io2.err("They timed out again when they were run one at a time (--concurrency 1), so they");
+      io2.err("most likely never finish. Look at each mutant first. Only for a");
+    } else {
+      const again = retried.statuses["Timeout"] ?? 0;
+      if (again > 0) {
+        io2.err(
+          `${again} of them timed out again when they were run one at a time (--concurrency 1).`
+        );
+      }
+      io2.err(
+        `${retried.missing} of them were not in the report of the run again (--concurrency 1),`
+      );
+      io2.err("so they keep the timeout of the first run. Look at each mutant first. Only for a");
+    }
     io2.err("mutant that can never finish (a loop that no longer ends), add it to");
     io2.err('"expectedTimeouts" of the gate in test-gates.json and fill in "reason"');
     io2.err("(settings.mutation.maxTimeouts raises the limit for the whole project):");
@@ -3116,16 +4445,16 @@ function runMutationResult(dir, reportOverride, io2, only = [], seen = () => voi
 // src/commands/mutation.ts
 var CONFIG_MARK = "\0test-gates-stryker-config\0";
 function loadStrykerConfig(manifest, config) {
-  const file = path8.resolve(manifest.dir, config);
+  const file = path10.resolve(manifest.dir, config);
   if (file.endsWith(".json")) {
     try {
-      return JSON.parse(fs8.readFileSync(file, "utf8"));
+      return JSON.parse(fs10.readFileSync(file, "utf8"));
     } catch {
       return void 0;
     }
   }
-  const script = `const loaded = await import(${JSON.stringify(pathToFileURL(file).href)});const config = loaded.default?.default ?? loaded.default ?? loaded;process.stdout.write(${JSON.stringify(CONFIG_MARK)} + JSON.stringify({incremental: config.incremental, force: config.force,incrementalFile: config.incrementalFile, tempDirName: config.tempDirName,testRunner: config.testRunner, vitestConfig: config.vitest?.configFile,jestConfig: config.jest?.configFile,}) + ${JSON.stringify(CONFIG_MARK)});`;
-  const result = spawnSync2(process.execPath, ["--input-type=module", "--eval", script], {
+  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, checkers: config.checkers,htmlReporter: config.htmlReporter, jsonReporter: config.jsonReporter,ignorePatterns: config.ignorePatterns, cleanTempDir: config.cleanTempDir,}) + ${JSON.stringify(CONFIG_MARK)});`;
+  const result = spawnSync4(process.execPath, ["--input-type=module", "--eval", script], {
     cwd: manifest.dir,
     encoding: "utf8",
     timeout: 6e4
@@ -3138,7 +4467,7 @@ function loadStrykerConfig(manifest, config) {
 }
 function modifiedAt(file) {
   try {
-    const stat = fs8.statSync(file, { bigint: true });
+    const stat = fs10.statSync(file, { bigint: true });
     return `${stat.mtimeNs} ${stat.ino}`;
   } catch {
     return null;
@@ -3147,6 +4476,7 @@ function modifiedAt(file) {
 function guardRecordPath(incrementalFile) {
   return `${incrementalFile}.test-gates.json`;
 }
+var forcedLine = (reason) => `test-gates mutation: running every mutant again (--force), the results of the last run are not reused: ${reason}`;
 function coveringSpecs(report, gates) {
   const fileOf = /* @__PURE__ */ new Map();
   for (const [file, entry] of Object.entries(report.testFiles ?? {})) {
@@ -3173,11 +4503,27 @@ function coveringSpecs(report, gates) {
   }
   return covering;
 }
-function decideReuse(manifest, config, strykerArgs, part, affected) {
+function readSeed(incrementalFile, recordFile) {
+  try {
+    const incremental = fs10.readFileSync(incrementalFile);
+    const record = JSON.parse(fs10.readFileSync(recordFile, "utf8"));
+    const named = record?.incremental;
+    return named === hashOf(incremental) ? { incremental, record } : null;
+  } catch {
+    return null;
+  }
+}
+function decideReuse(manifest, config, strykerArgs, part, affected, found = () => void 0) {
   const loaded = loadStrykerConfig(manifest, config);
   const options = incrementalOptions(loaded, strykerArgs);
-  const base = fs8.realpathSync(manifest.dir);
-  const configs = () => runnerConfigs(base, config, loaded ?? {});
+  const base = fs10.realpathSync(manifest.dir);
+  const checkersArg = strykerArgs.some(
+    (arg) => arg === "--checkers" || arg.startsWith("--checkers=")
+  );
+  const configs = () => runnerConfigs(base, config, {
+    ...loaded ?? {},
+    ...checkersArg ? { checkers: ["--checkers"] } : {}
+  });
   const decision = {
     incremental: false,
     incrementalFile: null,
@@ -3194,25 +4540,44 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
     last: void 0,
     ci: affected ? affectedRefused(process.env) : null,
     unchanged: null,
-    configs
+    configs,
+    temp: {
+      dir: loaded === void 0 ? null : path10.resolve(base, options.tempDirName),
+      keeps: loaded?.cleanTempDir === false
+    },
+    mainWorktree: null,
+    seed: null
   };
+  found(decision.temp);
   if (loaded !== void 0 && !options.incremental) {
     return decision;
   }
   decision.incremental = true;
-  const incrementalFile = path8.resolve(base, options.incrementalFile);
+  const incrementalFile = path10.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";
+  const reports = reportFiles(loaded).map((file) => path10.resolve(base, file));
+  const ignores = strykerIgnores(loaded);
+  const read2 = (file) => {
+    const relative = path10.relative(base, file);
+    const inside = !relative.startsWith("..") && !path10.isAbsolute(relative);
+    return !reports.includes(file) && !(inside && ignores(relative.split(path10.sep).join("/")));
+  };
   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;
+        const found2 = loadedScope(manifest, configs(), listed2);
+        if (!("files" in found2)) {
+          decision.scope = found2;
+          return null;
+        }
+        const files = new Set([...found2.files].filter(read2));
+        decision.scope = { files: files.size };
+        return files;
       } catch (error) {
         decision.scope = { every: error.message };
         return null;
@@ -3226,8 +4591,9 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
         written: [
           incrementalFile,
           recordFile,
-          path8.resolve(base, options.tempDirName),
-          path8.resolve(base, manifest.settings.strykerReportFile)
+          path10.resolve(base, options.tempDirName),
+          path10.resolve(base, manifest.settings.strykerReportFile),
+          ...reports
         ],
         args: comparableArgs(strykerArgs)
       }));
@@ -3239,17 +4605,32 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   decision.snapshot = snapshot;
   decision.failure = snapshot === null ? failure : null;
   decision.root = root;
-  const incremental = hashFile(incrementalFile);
+  const tempDir = path10.basename(options.tempDirName);
+  if (!part && !options.force && snapshot?.mode === "git" && !path10.relative(root, base).split(path10.sep).includes(tempDir) && !fs10.existsSync(incrementalFile) && !fs10.existsSync(recordFile)) {
+    const linked = linkedWorktreeOf(base);
+    const mainIncremental = linked === null ? null : inMainWorktree(linked, incrementalFile);
+    const mainRecord = linked === null ? null : inMainWorktree(linked, recordFile);
+    if (linked !== null && mainIncremental !== null && mainRecord !== null) {
+      decision.mainWorktree = linked.main;
+      const seed = readSeed(mainIncremental, mainRecord);
+      if (seed !== null) {
+        decision.seed = seed;
+      }
+    }
+  }
+  const incremental = decision.seed === null ? hashFile(incrementalFile) : hashOf(decision.seed.incremental);
   decision.incrementalHash = incremental;
   if (part) {
     decision.force = incremental !== null && !options.force ? "with --gate nothing is taken over from an earlier run" : null;
     return decision;
   }
-  let stored;
-  try {
-    stored = JSON.parse(fs8.readFileSync(recordFile, "utf8"));
-  } catch {
-    stored = void 0;
+  let stored = decision.seed?.record;
+  if (decision.seed === null) {
+    try {
+      stored = JSON.parse(fs10.readFileSync(recordFile, "utf8"));
+    } catch {
+      stored = void 0;
+    }
   }
   const ci = decision.ci;
   let force = null;
@@ -3260,14 +4641,21 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
       force = failure;
     } else if (!affected) {
       force = refuseReuse({ record: stored, incremental, snapshot });
+      if (force === null) {
+        const read3 = readRecord({ record: stored, incremental, snapshot });
+        last = "record" in read3 ? read3.record.affected : void 0;
+        if (decision.seed !== null) {
+          force = blindInMainRecord(manifest, { root, snapshot, configs, last });
+        }
+      }
     } else if (ci !== null) {
       force = ci;
     } else {
-      const read2 = readRecord({ record: stored, incremental, snapshot });
-      if ("refused" in read2) {
-        force = read2.refused;
+      const read3 = readRecord({ record: stored, incremental, snapshot });
+      if ("refused" in read3) {
+        force = read3.refused;
       } else {
-        last = read2.record.affected;
+        last = read3.record.affected;
         try {
           const inputs = affectedInputs(manifest, {
             root,
@@ -3279,14 +4667,16 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
             )
           });
           plan = planAffected({
-            before: { files: read2.record.snapshot.files, affected: last },
+            before: { files: read3.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 ?? []
-            }))
+              files: inputs.gates[gate.path]?.files ?? [],
+              blind: inputs.gates[gate.path]?.blind
+            })),
+            seeded: decision.seed !== null
           });
         } catch (error) {
           if (!(error instanceof AffectedError)) {
@@ -3295,7 +4685,7 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
           plan = { full: `what a gate depends on cannot be told: ${error.message}` };
         }
         if ("full" in plan) {
-          if (refuseReuse({ record: stored, incremental, snapshot }) === null) {
+          if (decision.seed === null && refuseReuse({ record: stored, incremental, snapshot }) === null) {
             decision.unchanged = plan.full;
             plan = null;
           } else {
@@ -3312,9 +4702,45 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   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);
+function blindInMainRecord(manifest, input) {
+  const { last } = input;
+  const unknown = last === void 0 ? "each gate" : manifest.gates.find((gate) => !Object.hasOwn(last.gates, gate.path))?.path;
+  if (last === void 0 || unknown !== void 0) {
+    return `the record of the main worktree does not say what ${unknown} depends on, so it may read files git does not list, which differ between worktrees`;
+  }
+  try {
+    const inputs = affectedInputs(manifest, {
+      root: input.root,
+      files: input.snapshot.files,
+      configs: input.configs(),
+      tests: last.tests,
+      covering: Object.fromEntries(
+        Object.entries(last.gates).map(([gate, entry]) => [gate, entry.specs])
+      )
+    });
+    for (const gate of manifest.gates) {
+      const blind = inputs.gates[gate.path]?.blind ?? last.gates[gate.path]?.blind;
+      if (blind !== void 0) {
+        return `${gate.path} may read files git does not list, which differ between worktrees (${blind})`;
+      }
+    }
+    return null;
+  } catch (error) {
+    if (!(error instanceof AffectedError)) {
+      throw error;
+    }
+    return `what a gate depends on cannot be told, so it may read files git does not list, which differ between worktrees: ${error.message}`;
+  }
+}
+function guardIncremental(manifest, config, strykerArgs, part, affected, found) {
+  const decision = decideReuse(manifest, config, strykerArgs, part, affected, found);
+  const nothing = {
+    force: null,
+    mutate: null,
+    said: [],
+    temp: decision.temp,
+    record: () => void 0
+  };
   if (!decision.incremental) {
     return affected ? {
       ...nothing,
@@ -3323,71 +4749,96 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       ]
     } : nothing;
   }
-  const { snapshot, root, plan, last, ci, configs, force } = decision;
+  const { snapshot, root, plan, last, 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 });
+    fs10.rmSync(recordFile, { force: true });
     return { ...nothing, force };
   }
-  fs8.rmSync(recordFile, { force: true });
+  if (decision.seed !== null) {
+    fs10.mkdirSync(path10.dirname(incrementalFile), { recursive: true });
+    fs10.writeFileSync(incrementalFile, decision.seed.incremental);
+  }
+  fs10.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 = [];
+  let timedOut = 0;
+  let expected = 0;
   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));
+    const kept = rerun === null ? manifest.gates : manifest.gates.filter((gate) => !rerun.includes(gate.path));
     try {
-      ranges = timeoutRanges(
-        JSON.parse(fs8.readFileSync(incrementalFile, "utf8")),
+      ({
+        ranges,
+        rerun: timedOut,
+        expected
+      } = timeoutRanges(
+        JSON.parse(fs10.readFileSync(incrementalFile, "utf8")),
         kept
-      );
+      ));
     } catch {
-      ranges = [];
     }
   }
   const subset = rerun !== null && rerun.length > 0 && everyGate === null ? rerun : [];
+  const ran = affected ? rerun : everyGate !== null || options.force || incremental === null ? null : [];
   let said = [];
   if (affected && !options.force) {
     if (force !== null) {
       said = describePlan({ full: force });
     } else if (plan !== null) {
-      said = describePlan(plan, 5, ranges.length);
+      said = describePlan(plan, 5, timedOut, expected);
     } 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`] : []
+        ...ranges.length > 0 ? [`  and ${timedOut} mutant(s) that timed out in the last run are run again`] : [],
+        ...expected > 0 ? [`  ${describeExpected(expected)}`] : []
       ];
     }
-  } 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`
-    ];
+  } else {
+    if (ranges.length > 0) {
+      said.push(
+        `test-gates mutation: ${timedOut} mutant(s) that timed out in the last run are run again, the other results are reused`
+      );
+    }
+    if (expected > 0) {
+      said.push(`test-gates mutation: ${describeExpected(expected)}`);
+    }
+  }
+  if (decision.seed !== null) {
+    if (said.length === 0 && everyGate !== null) {
+      said.push(forcedLine(everyGate));
+    }
+    said.unshift(
+      `test-gates mutation: this worktree has no record of its own, so it starts from the one of the main worktree (${decision.mainWorktree})`
+    );
   }
   return {
     // Every gate is run again: the same as a run of every mutant.
     force: everyGate,
     mutate: subset.length + ranges.length > 0 ? [...subset, ...ranges] : null,
     said,
+    temp: decision.temp,
     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);
+      if (affectedRefused(process.env) === null && judged !== null) {
+        record.affected = affectedRecord(judged, ran, last);
       }
       try {
-        fs8.writeFileSync(recordFile, `${JSON.stringify(record)}
+        fs10.writeFileSync(recordFile, `${JSON.stringify(record)}
 `);
       } catch {
       }
     }
   };
-  function affectedRecord(judged, ran, previous) {
+  function affectedRecord(judged, ran2, previous) {
     const gates = manifest.gates.map((gate) => gate.path);
     const dirty = new Set(
       [...judged.verdict.survivors, ...judged.verdict.unexpectedTimeouts].map((one) => one.file)
@@ -3395,7 +4846,7 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
     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;
+      const specs = ran2 === null || ran2.includes(gate) ? fresh[gate] : previous?.gates[gate]?.specs ?? null;
       if (specs !== null && specs !== void 0 && !dirty.has(gate)) {
         covering[gate] = specs;
       }
@@ -3412,12 +4863,16 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       for (const gate of Object.keys(covering)) {
         const entry = inputs.gates[gate];
         if (entry !== void 0) {
-          recorded[gate] = { specs: entry.specs, files: entry.files };
+          recorded[gate] = {
+            specs: entry.specs,
+            files: entry.files,
+            ...entry.blind === void 0 ? {} : { blind: entry.blind }
+          };
         }
       }
       return { tests: Object.keys(judged.report.testFiles ?? {}).sort(), gates: recorded };
     } catch (error) {
-      if (error instanceof AffectedError) {
+      if (error instanceof AffectedError || !affected) {
         return void 0;
       }
       throw error;
@@ -3463,53 +4918,120 @@ function runMutation(dir, strykerArgs, io2, only = [], affected = false) {
     );
   }
   const reportFile = reportPathOf(manifest, null);
-  fs8.rmSync(reportFile, { force: true });
-  const guard = guardIncremental(manifest, config, strykerArgs, part, affected);
+  fs10.rmSync(reportFile, { force: true });
+  let removed = [];
+  const guard = guardIncremental(manifest, config, strykerArgs, part, affected, (temp) => {
+    removed = removeStaleSandboxes(manifest.dir, temp);
+  });
   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}`
-    );
+    io2.out(forcedLine(guard.force));
   }
+  removed.forEach((line) => io2.out(line));
   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`
+  const unmark = markRun(manifest.dir, guard.temp);
+  let retried;
+  try {
+    const result = spawnSync4(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;
+    }
+    retried = retryTimeouts(
+      stryker,
+      [config, ...strykerArgs],
+      manifest,
+      reportFile,
+      part ? manifest.gates.filter((gate) => chosen.selected.includes(gate.path)) : manifest.gates,
+      io2
     );
-    return 1;
+  } finally {
+    unmark();
   }
   let judged = null;
-  const status = runMutationResult(dir, null, io2, part ? chosen.selected : [], (seen) => {
-    judged = seen;
-  });
+  const status = runMutationResult(
+    dir,
+    null,
+    io2,
+    part ? chosen.selected : [],
+    (seen) => {
+      judged = seen;
+    },
+    retried
+  );
   guard.record(judged);
   if (part) {
-    fs8.rmSync(reportFile, { force: true });
+    fs10.rmSync(reportFile, { force: true });
   }
   return status;
 }
+function retryTimeouts(stryker, args, manifest, reportFile, gates, io2) {
+  let first;
+  try {
+    first = JSON.parse(fs10.readFileSync(reportFile, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof first !== "object" || first === null) {
+    return null;
+  }
+  const { ranges, rerun } = timeoutRanges(first, gates);
+  if (ranges.length === 0 || rerun <= manifest.settings.maxTimeouts) {
+    return null;
+  }
+  io2.out(
+    `test-gates mutation: ${rerun} mutant(s) timed out outside expectedTimeouts, running them again one at a time (--concurrency 1)`
+  );
+  fs10.rmSync(reportFile, { force: true });
+  const result = spawnSync4(
+    stryker,
+    ["run", ...args, "--mutate", ranges.join(","), "--concurrency", "1", "--force"],
+    { cwd: manifest.dir, stdio: "inherit", shell: process.platform === "win32" }
+  );
+  let retry = null;
+  if (!result.error && result.status === 0) {
+    try {
+      retry = JSON.parse(fs10.readFileSync(reportFile, "utf8"));
+    } catch {
+      retry = null;
+    }
+  }
+  if (retry === null || typeof retry !== "object") {
+    const why = result.error ? result.error.message : result.signal ? `signal ${result.signal}` : result.status === 0 ? "no report" : `exit ${result.status}`;
+    io2.err(
+      `test-gates mutation: running the timed-out mutants again failed (${why}). The first run is judged`
+    );
+    fs10.writeFileSync(reportFile, JSON.stringify(first));
+    return "failed";
+  }
+  const merged = mergeRetry(first, retry, gates);
+  fs10.writeFileSync(reportFile, JSON.stringify(merged.report));
+  io2.out(formatRetry(merged.outcome));
+  return merged.outcome;
+}
 
 // src/commands/doctor.ts
 function read(file) {
   try {
-    return fs9.readFileSync(file, "utf8");
+    return fs11.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 }
-function git2(dir, args) {
-  const result = spawnSync3("git", args, {
+function git3(dir, args) {
+  const result = spawnSync5("git", args, {
     cwd: dir,
     env: gitEnvironment(process.env),
     encoding: "utf8"
@@ -3517,20 +5039,20 @@ function git2(dir, args) {
   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 root = git3(dir, ["rev-parse", "--show-toplevel"]) ?? dir;
+  const hooksDir = git3(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))
+    ...["pre-push", "pre-commit"].map((name) => path11.join(root, ".husky", name)),
+    ...hooksDir === null ? [] : ["pre-push", "pre-commit"].map((name) => path11.join(hooksDir, name)),
+    ...["lefthook.yml", ".lefthook.yml"].map((name) => path11.join(root, name))
   ];
   let script = "";
   try {
-    const manifest = JSON.parse(read(path9.join(dir, "package.json")) ?? "{}");
+    const manifest = JSON.parse(read(path11.join(dir, "package.json")) ?? "{}");
     script = manifest.scripts?.["test:gates:mutation"] ?? "";
   } catch {
   }
-  const subproject = path9.relative(fs9.realpathSync(root), dir).split(path9.sep).join("/");
+  const subproject = path11.relative(fs11.realpathSync(root), dir).split(path11.sep).join("/");
   const seen = /* @__PURE__ */ new Set();
   const uses = [];
   for (const file of candidates) {
@@ -3538,12 +5060,12 @@ function hooksOf(dir) {
     if (text === null) {
       continue;
     }
-    const real = fs9.realpathSync(file);
+    const real = fs11.realpathSync(file);
     if (seen.has(real)) {
       continue;
     }
     seen.add(real);
-    const shown = path9.relative(root, file).split(path9.sep).join("/");
+    const shown = path11.relative(root, file).split(path11.sep).join("/");
     uses.push(...hookUses({ file: shown, text, subproject, script }));
   }
   return uses;
@@ -3560,8 +5082,8 @@ function runDoctor(dir, io2) {
   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 subproject = path11.relative(plain2.root, fs11.realpathSync(manifest.dir));
+    const prefix = subproject === "" ? "" : `${subproject.split(path11.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";
@@ -3572,6 +5094,15 @@ function runDoctor(dir, io2) {
     io2.out(
       reuse === null ? "  next run: reuses the results of the last run" : `  next run: every mutant, ${reuse}`
     );
+    if (plain2.seed !== null) {
+      io2.out(
+        `  this worktree has no record of its own: the next run starts from the one of the main worktree (${plain2.mainWorktree})`
+      );
+    } else if (plain2.mainWorktree !== null) {
+      io2.out(
+        `  this worktree has no record of its own, and the main worktree (${plain2.mainWorktree}) has none this worktree can start from`
+      );
+    }
     if (affected.ci !== null) {
       io2.out(`  next run with --affected: every mutant, ${affected.ci}`);
     } else if (affected.plan !== null && "rerun" in affected.plan) {
@@ -3588,15 +5119,20 @@ function runDoctor(dir, io2) {
     }
   }
   let blind = null;
+  let blindGates = [];
   if (plain2.snapshot !== null) {
     try {
-      affectedInputs(manifest, {
+      const inputs = affectedInputs(manifest, {
         root: plain2.root,
         files: plain2.snapshot.files,
         configs: plain2.configs(),
         tests: [],
         covering: {}
       });
+      blindGates = manifest.gates.flatMap((gate) => {
+        const reason = inputs.gates[gate.path]?.blind;
+        return reason === void 0 ? [] : [{ gate: gate.path, reason }];
+      });
     } catch (error) {
       if (!(error instanceof AffectedError)) {
         throw error;
@@ -3604,6 +5140,8 @@ function runDoctor(dir, io2) {
       blind = error.message;
     }
   }
+  const left = sandboxPlan(manifest.dir, plain2.temp);
+  const count = "kept" in left.plan ? left.plan.kept.length : left.plan.remove.length;
   const { lines, status } = formatFindings(
     diagnose({
       incremental: plain2.incremental,
@@ -3611,8 +5149,16 @@ function runDoctor(dir, io2) {
       failure: plain2.failure,
       widened: plain2.widened,
       scope: plain2.scope,
-      hooks: hooksOf(fs9.realpathSync(manifest.dir)),
-      blind
+      hooks: hooksOf(fs11.realpathSync(manifest.dir)),
+      blind,
+      blindGates,
+      gates: manifest.gates.length,
+      sandboxes: count === 0 ? null : {
+        tempDir: left.shown,
+        count,
+        kept: "kept" in left.plan ? left.plan.why : null,
+        running: "kept" in left.plan ? left.plan.running : null
+      }
     })
   );
   lines.forEach((line) => io2.out(line));
@@ -3620,8 +5166,8 @@ function runDoctor(dir, io2) {
 }
 
 // src/commands/lcov.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path12 from "path";
 
 // src/core/lcov.ts
 function normalizePath2(file, rootDir) {
@@ -3648,9 +5194,9 @@ function parseLcov(text, rootDir) {
     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);
+      const path15 = normalizePath2(line.slice(3), rootDir);
+      const file = files.get(path15) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path15, file);
       record = { file, hasDa: false, found: 0, hit: 0 };
     } else if (line === "end_of_record") {
       closeRecord();
@@ -3734,10 +5280,10 @@ function runLcov(dir, fileOption, io2) {
       "no lcov file given. Pass --file <lcov.info> or set settings.lcov.file"
     );
   }
-  const lcovPath = path10.resolve(manifest.dir, file);
+  const lcovPath = path12.resolve(manifest.dir, file);
   let text;
   try {
-    text = fs10.readFileSync(lcovPath, "utf8");
+    text = fs12.readFileSync(lcovPath, "utf8");
   } catch (error) {
     io2.err(
       `test-gates lcov: cannot read ${file} (${error.message}). Run the tests with coverage first`
@@ -3780,10 +5326,10 @@ function runLcov(dir, fileOption, io2) {
 }
 
 // src/commands/selfcheck.ts
-import { spawn, spawnSync as spawnSync4 } from "child_process";
-import fs12 from "fs";
+import { spawn, spawnSync as spawnSync6 } from "child_process";
+import fs14 from "fs";
 import os2 from "os";
-import path12 from "path";
+import path14 from "path";
 
 // src/core/jobs.ts
 var SWITCHES = {
@@ -3823,6 +5369,34 @@ function knownCommand(program, args) {
 function jobFlags(runner, dir) {
   return runner === "jest" ? [`--coverageDirectory=${dir}/coverage`, `--cacheDirectory=${dir}/cache`] : [`--coverage.reportsDirectory=${dir}/coverage`, "--no-cache"];
 }
+var LIMITS = {
+  jest: ["--runInBand", "-i", "--maxWorkers", "-w"],
+  vitest: ["--no-file-parallelism", "--fileParallelism", "--maxWorkers", "--minWorkers"]
+};
+var CONFIG_LIMITS = [
+  "maxWorkers",
+  "minWorkers",
+  "maxThreads",
+  "minThreads",
+  "maxForks",
+  "minForks",
+  "fileParallelism",
+  "singleThread",
+  "singleFork"
+];
+function workerFlags(input) {
+  if (input.lines <= 1) {
+    return [];
+  }
+  const given = input.args.some(
+    (arg) => LIMITS[input.runner].includes(arg.split("=")[0])
+  );
+  const configured = CONFIG_LIMITS.some((word) => input.configSource?.includes(word) === true);
+  if (given || configured) {
+    return [];
+  }
+  return [`--maxWorkers=${Math.max(1, Math.floor(input.cores / input.lines))}`];
+}
 var REACHES = [
   "process.",
   "process?.",
@@ -3854,10 +5428,22 @@ var REACHES = [
 ];
 var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])|\bimport\.meta\.glob\b/;
 var COMPUTED = "loads a module whose name is computed";
+var STRING = /(^|[:,([={?+&|;])(\s*)(['"])((?:\\.|(?!\3)[^\\\n])*)\3(?=\s*(?:[,}\]);:+?&|]|$))/gm;
+function withoutStrings(source) {
+  return source.replace(
+    STRING,
+    (all, before, space, quote, inside) => (
+      // In a template (`{"home": "${home()}"}`) the quotes are text, and what is
+      // between them may be code.
+      inside.includes("${") ? all : `${before}${space}${quote}${" ".repeat(inside.length)}${quote}`
+    )
+  );
+}
 var RUNNER_PACKAGES = ["vitest", "@jest/globals"];
 function reachesOutside(file, trusted) {
   const dense = file.source.replace(/\s/g, "");
-  const mark = REACHES.find((text) => dense.includes(text));
+  const code = withoutStrings(file.source).replace(/\s/g, "");
+  const mark = REACHES.find((text) => code.includes(text));
   if (mark !== void 0) {
     return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
   }
@@ -4000,8 +5586,8 @@ function cleanHold(input) {
 
 // src/touch.ts
 import { createHash as createHash2 } from "crypto";
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import { fileURLToPath } from "url";
 var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
 function isObject(value) {
@@ -4035,7 +5621,7 @@ function isCounters(value) {
 function readNotes(directory) {
   const read2 = (file) => {
     try {
-      return JSON.parse(fs11.readFileSync(path11.join(directory, file), "utf8"));
+      return JSON.parse(fs13.readFileSync(path13.join(directory, file), "utf8"));
     } catch {
       return null;
     }
@@ -4043,8 +5629,8 @@ function readNotes(directory) {
   const run = read2("run.json");
   let notes = [];
   try {
-    for (const name of fs11.readdirSync(path11.join(directory, "specs"))) {
-      const note = read2(path11.join("specs", name));
+    for (const name of fs13.readdirSync(path13.join(directory, "specs"))) {
+      const note = read2(path13.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");
       }
@@ -4056,7 +5642,7 @@ 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(read2(path11.join("coverage", "coverage-final.json")))
+    totals: countersOfAll(read2(path13.join("coverage", "coverage-final.json")))
   };
 }
 
@@ -4071,7 +5657,7 @@ function resolveGateCommand(manifest) {
   if (manifest.settings.gateCommand !== null) {
     return manifest.settings.gateCommand;
   }
-  const exists = (name) => fs12.existsSync(path12.join(manifest.dir, name));
+  const exists = (name) => fs14.existsSync(path14.join(manifest.dir, name));
   const jest = JEST_CONFIGS.find(exists);
   const vitest = VITEST_CONFIGS.find(exists);
   if (jest && vitest) {
@@ -4092,7 +5678,7 @@ function resolveGateCommand(manifest) {
 var TOUCH_PREFIX = ".test-gates-touch-";
 function realPath(file) {
   try {
-    return fs12.realpathSync(file);
+    return fs14.realpathSync(file);
   } catch {
     return file;
   }
@@ -4100,13 +5686,16 @@ function realPath(file) {
 function shareOneRun(manifest, targets, runGate) {
   let touchDir;
   try {
-    for (const name of fs12.readdirSync(manifest.dir)) {
-      const left = path12.join(manifest.dir, name);
-      if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
-        fs12.rmSync(left, { recursive: true, force: true });
+    for (const name of fs14.readdirSync(manifest.dir)) {
+      const left = path14.join(manifest.dir, name);
+      try {
+        if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs14.statSync(left).mtimeMs > 36e5) {
+          fs14.rmSync(left, { recursive: true, force: true });
+        }
+      } catch {
       }
     }
-    touchDir = fs12.mkdtempSync(path12.join(manifest.dir, TOUCH_PREFIX));
+    touchDir = fs14.mkdtempSync(path14.join(manifest.dir, TOUCH_PREFIX));
   } catch {
     return { reason: "the subproject cannot be written to" };
   }
@@ -4117,14 +5706,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(path12.resolve(base, file));
+    const absolute = (file) => realPath(path14.resolve(base, file));
     const rekeyed = (files) => Object.fromEntries(Object.entries(files).map(([file, value]) => [absolute(file), value]));
     const left = readNotes(touchDir);
     plan = planControls({
       all: manifest.gates.map((gate) => ({
         path: gate.path,
-        file: path12.join(base, gate.path),
-        specFile: path12.join(base, gate.spec ?? "")
+        file: path14.join(base, gate.path),
+        specFile: path14.join(base, gate.spec ?? "")
       })),
       targets: targets.map((gate) => gate.path),
       run: left.run,
@@ -4133,7 +5722,7 @@ function shareOneRun(manifest, targets, runGate) {
       failurePattern: manifest.settings.selfcheckFailurePattern
     });
   } finally {
-    fs12.rmSync(touchDir, { recursive: true, force: true });
+    fs14.rmSync(touchDir, { recursive: true, force: true });
   }
   if (plan.reason !== null) {
     return { reason: plan.reason };
@@ -4143,15 +5732,15 @@ function shareOneRun(manifest, targets, runGate) {
   return { gates, result: runGate({ excludeAll: gates.map((gate) => gate.spec) }) };
 }
 function installedVersion2(start, name) {
-  let current = path12.resolve(start);
+  let current = path14.resolve(start);
   for (; ; ) {
     try {
       const manifest = JSON.parse(
-        fs12.readFileSync(path12.join(current, "node_modules", name, "package.json"), "utf8")
+        fs14.readFileSync(path14.join(current, "node_modules", name, "package.json"), "utf8")
       );
       return typeof manifest.version === "string" ? manifest.version : null;
     } catch {
-      const parent = path12.dirname(current);
+      const parent = path14.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -4180,24 +5769,39 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
   const results = /* @__PURE__ */ new Map();
   let root;
   try {
-    for (const name of fs12.readdirSync(os2.tmpdir())) {
-      const left = path12.join(os2.tmpdir(), name);
-      if (name.startsWith(JOBS_PREFIX) && Date.now() - fs12.statSync(left).mtimeMs > 36e5) {
-        fs12.rmSync(left, { recursive: true, force: true });
+    root = fs14.realpathSync(fs14.mkdtempSync(path14.join(os2.tmpdir(), JOBS_PREFIX)));
+  } catch {
+    return results;
+  }
+  try {
+    for (const name of fs14.readdirSync(os2.tmpdir())) {
+      const left = path14.join(os2.tmpdir(), name);
+      try {
+        if (name.startsWith(JOBS_PREFIX) && Date.now() - fs14.statSync(left).mtimeMs > 36e5) {
+          fs14.rmSync(left, { recursive: true, force: true });
+        }
+      } catch {
       }
     }
-    root = fs12.realpathSync(fs12.mkdtempSync(path12.join(os2.tmpdir(), JOBS_PREFIX)));
   } catch {
-    return results;
   }
   const queue = [...gates];
+  const lines = Math.min(jobs, gates.length);
+  const workers = workerFlags({
+    runner,
+    args,
+    configSource: gateConfigSource(manifest, args),
+    lines,
+    // (os.availableParallelism is in Node 18.14 and later.)
+    cores: os2.availableParallelism?.() ?? os2.cpus().length
+  });
   const line = async (dir) => {
     for (let gate = queue.shift(); gate !== void 0; gate = queue.shift()) {
       const spec = gate.spec;
       results.set(
         gate,
         await new Promise((resolve) => {
-          const child = spawn(executable, [...args, ...jobFlags(runner, dir)], {
+          const child = spawn(executable, [...args, ...jobFlags(runner, dir), ...workers], {
             cwd: manifest.dir,
             env: { ...process.env, [EXCLUDE_ENV]: spec, [EXCLUDE_ALL_ENV]: "", [TOUCH_ENV]: "" },
             shell: process.platform === "win32"
@@ -4216,13 +5820,10 @@ async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
   };
   try {
     await Promise.all(
-      Array.from(
-        { length: Math.min(jobs, gates.length) },
-        (_unused, index) => line(path12.join(root, `line-${index}`))
-      )
+      Array.from({ length: lines }, (_unused, index) => line(path14.join(root, `line-${index}`)))
     );
   } finally {
-    fs12.rmSync(root, { recursive: true, force: true });
+    fs14.rmSync(root, { recursive: true, force: true });
   }
   return results;
 }
@@ -4251,7 +5852,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) => spawnSync4(executable, args, {
+  const runGate = (env) => spawnSync6(executable, args, {
     cwd: manifest.dir,
     env: {
       ...process.env,
@@ -4329,6 +5930,11 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
           ...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);
+        if (results.size === 0) {
+          io2.out(
+            `test-gates selfcheck: one negative control at a time (no directory for the runs next to others could be made in ${os2.tmpdir()})`
+          );
+        }
         for (const [gate, result] of results) {
           const output = `${result.stdout}${result.stderr}`;
           const clean = cleanHold({
@@ -4346,7 +5952,7 @@ async function runSelfcheck(dir, selection, commandOverride, io2) {
           }
         }
         const again = atOnce.length - heldAtOnce.size;
-        if (again > 0) {
+        if (again > 0 && results.size > 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`
           );