@t09tanaka/test-gates 0.4.1 → 0.4.2

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") {
@@ -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 partsOf2 = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
+  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf2(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], partsOf2(gate)) !== "yes") {
       return false;
     }
     const touching = notes.filter((note) => {
@@ -1413,6 +1423,279 @@ import { spawnSync as spawnSync3 } from "child_process";
 import fs9 from "fs";
 import path9 from "path";
 
+// src/core/mutation-result.ts
+var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
+var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
+function normalizeCode(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizePath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function sliceByLocation(source, location) {
+  const lines = source.split("\n");
+  const { start, end } = location;
+  const first = lines[start.line - 1];
+  const last = lines[end.line - 1];
+  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+    return null;
+  }
+  if (start.line === end.line) {
+    return first.slice(start.column - 1, end.column - 1);
+  }
+  return [
+    first.slice(start.column - 1),
+    ...lines.slice(start.line, end.line - 1),
+    last.slice(0, end.column - 1)
+  ].join("\n");
+}
+function keyOf(mutator, original, replacement) {
+  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+}
+function 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);
+  }
+  for (const group of byKey.values()) {
+    for (const entry of group) {
+      entry.sameKeyCount = group.length;
+    }
+  }
+  return { located, byKey, outside };
+}
+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 { target: group[(entry.occurrence ?? 1) - 1] };
+}
+function expectedTimeoutMutants(gate, source, mutants) {
+  const pointed = /* @__PURE__ */ new Set();
+  if (source === void 0 || !Array.isArray(gate.expectedTimeouts)) {
+    return pointed;
+  }
+  const { byKey, outside } = locateMutants(source, mutants);
+  if (outside.length > 0) {
+    return pointed;
+  }
+  for (const entry of gate.expectedTimeouts) {
+    if (!isUsableEquivalentMutant(entry)) {
+      continue;
+    }
+    const found = resolveEntry(entry, byKey);
+    if ("target" in found && found.target !== void 0) {
+      pointed.add(found.target.mutant);
+    }
+  }
+  return pointed;
+}
+function describeMutant(file, entry) {
+  const { mutant } = entry;
+  return {
+    file,
+    line: mutant.location.start.line,
+    column: mutant.location.start.column,
+    status: mutant.status,
+    mutator: mutant.mutatorName,
+    original: normalizeCode(entry.original),
+    replacement: normalizeCode(entry.replacement),
+    occurrence: entry.occurrence,
+    sameKeyCount: entry.sameKeyCount,
+    allowance: {
+      mutator: mutant.mutatorName,
+      original: normalizeCode(entry.original),
+      replacement: normalizeCode(entry.replacement),
+      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
+      reason: ""
+    }
+  };
+}
+function describeAllowance(entry) {
+  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
+  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+}
+function judgeMutationReport(input) {
+  const violations = [];
+  const survivors = [];
+  const unexpectedTimeouts = [];
+  const summary = {
+    total: 0,
+    detected: 0,
+    timeout: 0,
+    allowed: 0,
+    notEvaluable: 0,
+    unallowed: 0,
+    expectedTimeout: 0
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, result] of Object.entries(input.report.files ?? {})) {
+    files.set(normalizePath(file), result);
+  }
+  for (const gate of input.gates) {
+    const gatePath = normalizePath(gate.path);
+    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
+    violations.push(...shapeViolations);
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
+    const result = files.get(gatePath);
+    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: "no mutants in the report (the gate was not mutation tested)"
+      });
+      continue;
+    }
+    const diskSource = input.readSource(gate.path);
+    const source = result.source ?? diskSource;
+    if (source === void 0) {
+      violations.push({
+        file: gate.path,
+        message: "source is neither in the report nor readable on disk"
+      });
+      continue;
+    }
+    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
+      violations.push({
+        file: gate.path,
+        message: "the report was made from a different version of this file. Run Stryker again"
+      });
+      continue;
+    }
+    const { located, 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 };
+}
+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 = 2;
 function isStringRecord(value) {
@@ -1531,6 +1814,53 @@ function incrementalOptions(config, args) {
 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 = [
@@ -1545,25 +1875,33 @@ var CONFIG_NAMES = [
   // Declarations need no import to take effect.
   /\.d\.[cm]?ts$/
 ];
-var CONFIG_DIRECTORIES = ["__mocks__", "node_modules"];
+var ROOT_MOCKS = "__mocks__";
 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 segments = localSegments(key, subproject);
   const name = segments[segments.length - 1];
-  if (segments.some((segment) => CONFIG_DIRECTORIES.includes(segment)) || CONFIG_NAMES.some((pattern) => pattern.test(name))) {
+  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)) {
     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 result = /* @__PURE__ */ Object.create(null);
@@ -1587,7 +1925,7 @@ 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)"
+      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);
@@ -1596,7 +1934,8 @@ function planAffected(input) {
   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);
+    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)}` };
@@ -1624,23 +1963,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}`
@@ -1661,8 +2010,14 @@ function describePlan(plan, shown = 5, timeouts = 0) {
   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";
@@ -1781,25 +2136,52 @@ 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 fs4.statSync(file, { throwIfNoEntry: false })?.isFile() === true;
   } catch {
     return false;
   }
 }
-function resolveFile(base, directory = true) {
-  const candidates = [
-    base,
-    ...EXTENSIONS.map((extension) => base + extension),
-    // `./fee.js` written in a TypeScript file is `./fee.ts`
-    ...EXTENSIONS.map((extension) => base.replace(/\.[cm]?jsx?$/, extension)),
-    ...directory ? EXTENSIONS.map((extension) => path4.join(base, `index${extension}`)) : []
-  ];
-  return candidates.find(isFile) ?? null;
-}
-function installed(specifier, from) {
+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}`)) : []
+  ];
+  const data = [`${base}.json`, ...directory ? [path4.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))) {
@@ -1811,14 +2193,17 @@ function installed(specifier, from) {
   }
 }
 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 target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFile(path4.resolve(path4.dirname(from), specifier));
+      return resolveFiles(path4.resolve(path4.dirname(from), specifier));
     }
     const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
-    return alias === void 0 ? null : resolveFile(
+    return alias === void 0 ? [] : resolveFiles(
       path4.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
     );
   };
@@ -1843,16 +2228,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(path4.resolve(path4.dirname(file), stripped), false);
+      const found = here.length > 0 ? here : resolveFiles(path4.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 +2256,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 +2270,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(path4.resolve(path4.dirname(file), text)));
     }
     const visited = {
       file: { path: relative(file), source, imports },
@@ -1957,10 +2341,11 @@ 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");
@@ -1996,9 +2381,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(path5.relative(root, directory)));
     const pattern = recursive ? `${relative === "" ? "" : `${relative}/`}**` : `${relative === "" ? "" : `${relative}/`}*`;
     const listed2 = git(root, [
       "ls-files",
@@ -2122,11 +2510,24 @@ function installedVersion(start, name) {
     }
   }
 }
+function nodeOnPath(cwd) {
+  const result = spawnSync("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) {
+  return resolving(() => snapshotNow(input));
+}
+function snapshotNow(input) {
   const dir = fs5.realpathSync(input.dir);
   const top = git(dir, ["rev-parse", "--show-toplevel"]);
   let root = top === null ? dir : fs5.realpathSync(top.trim());
@@ -2180,19 +2581,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 = path5.resolve(start, fixed);
+      let isDirectory2 = false;
+      try {
+        isDirectory2 = fs5.statSync(target).isDirectory();
+      } catch {
+      }
+      return {
+        target,
+        isDirectory: isDirectory2,
+        found: isDirectory2 || resolveFile(target, true, false) !== null
+      };
+    };
+    const fromFile = from(path5.dirname(file));
+    const targets = [fromFile];
+    if (!anchored && path5.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(path5.relative(listRoot, target))] = "missing";
+        continue;
+      }
+      const directory = isDirectory2 ? target : path5.dirname(target);
+      if (fs5.existsSync(directory)) {
+        enqueue(directory, file, reference, anchored && !open);
+      }
+    }
+  };
+  const reached = /* @__PURE__ */ new Set();
+  const reach = (file) => {
+    if (reached.has(file) || DOCUMENTS.includes(path5.extname(file).toLowerCase())) {
+      return;
+    }
+    reached.add(file);
+    let text;
     try {
-      isDirectory = fs5.statSync(target).isDirectory();
+      const content = fs5.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) => {
@@ -2264,8 +2720,17 @@ function snapshotOf(input) {
     }
   };
   const ancestors = upTo(dir, listRoot).slice(1);
-  for (const directory of ancestors) {
-    list(directory, false).forEach(add);
+  const besideAncestors = /* @__PURE__ */ new Set();
+  const ancestorFiles = ancestors.flatMap((directory) => list(directory, false));
+  for (const relative of ancestorFiles) {
+    besideAncestors.add(path5.join(listRoot, relative));
+  }
+  ancestorFiles.forEach(add);
+  for (const directory of [dir, ...ancestors]) {
+    const patches = path5.join(directory, "patches");
+    if (fs5.existsSync(patches) && fs5.statSync(patches).isDirectory()) {
+      enqueue(patches, directory);
+    }
   }
   for (const directory of [dir, ...ancestors]) {
     for (const linked of linkedPackages(path5.join(directory, "node_modules"), listRoot)) {
@@ -2287,11 +2752,23 @@ function snapshotOf(input) {
       }
     }
   }
-  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 = path5.relative(listRoot, file).split(path5.sep);
+    if (isInside(listRoot, file) && !parts.some((part) => NEVER.includes(part)) && fs5.statSync(file, { throwIfNoEntry: false })?.isFile() === true) {
+      add(toPosix(path5.relative(listRoot, file)));
+    }
   }
+  drain();
   const environment = {
     "Node.js": process.version,
+    ...nodeOnPath(dir),
     platform: `${process.platform} ${process.arch}`,
     "test-gates": ownVersion()
   };
@@ -2310,7 +2787,17 @@ import { builtinModules as builtinModules2 } from "module";
 import path6 from "path";
 var AffectedError = class extends Error {
 };
-var RUNTIME_PATHS = /\b(?:__dirname|__filename|require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readdirSync)\b|\bimport\.meta\.(?:url|dirname|filename|glob|resolve)\b/;
+var RUNTIME_PATHS = /\b(?:require\.(?:context|resolve)|process\.cwd|createRequire|toMatchFileSnapshot|readFileSync|readdirSync)\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_SAFE = /* @__PURE__ */ new Set([
+  "path",
+  "path/posix",
+  "path/win32",
+  "url",
+  "vitest",
+  "@jest/globals"
+]);
 var FILE_MODULES = /* @__PURE__ */ new Set([
   "fs",
   "fs/promises",
@@ -2366,10 +2853,98 @@ function runnerConfigs(dir, stryker, options) {
       }
     }
   }
-  return { files: files.filter((file) => fs6.existsSync(file)).map(realpath) };
+  return {
+    files: files.filter((file) => fs6.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(path6.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 = path6.dirname(dir); ; current = path6.dirname(current)) {
+    const relative = path6.relative(root, current);
+    if (relative.startsWith("..") || path6.isAbsolute(relative)) {
+      break;
+    }
+    above.add(current);
+    if (current === path6.dirname(current)) {
+      break;
+    }
+  }
+  const compared = new Set(keys.map((key) => path6.join(root, key)));
+  const starts = [...compared].filter(
+    (file) => (COMPILER_CONFIG.test(path6.basename(file)) || path6.basename(file) === "package.json") && (file.startsWith(`${dir}${path6.sep}`) || above.has(path6.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(path6.sep).includes("node_modules")) {
+      try {
+        text = fs6.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`,
+    path6.join(start, "tsconfig.json")
+  ];
+  if (base.startsWith(".") || path6.isAbsolute(base)) {
+    return candidates(path6.resolve(path6.dirname(from), base)).find(isFile2) ?? null;
+  }
+  for (let current = path6.dirname(from); ; current = path6.dirname(current)) {
+    const file = candidates(path6.join(current, "node_modules", base)).find(isFile2);
+    if (file !== void 0) {
+      return file;
+    }
+    if (current === path6.dirname(current)) {
+      return null;
+    }
+  }
+}
+function isFile2(file) {
+  try {
+    return fs6.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;
@@ -2377,10 +2952,10 @@ function fileEdges(file, context) {
   const shown = (one) => toPosix2(path6.relative(dir, one));
   const target = (specifier, from) => {
     if (specifier.startsWith(".")) {
-      return resolveFile(path6.resolve(path6.dirname(from), specifier));
+      return resolveFiles(path6.resolve(path6.dirname(from), specifier));
     }
     const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
-    return alias === void 0 ? null : resolveFile(path6.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
+    return alias === void 0 ? [] : resolveFiles(path6.resolve(dir, alias.target + specifier.slice(alias.prefix.length)));
   };
   const found = { loads: [], unknown: null, computed: false, unnamed: [] };
   cache.set(file, found);
@@ -2392,41 +2967,61 @@ function fileEdges(file, context) {
   if (fs6.existsSync(snapshotFile)) {
     found.loads.push(realpath(snapshotFile));
   }
+  const mocks = path6.join(path6.dirname(file), "__mocks__");
+  const name = path6.basename(file);
+  const candidates = isDirectory(mocks) ? [
+    path6.join(mocks, name),
+    ...resolveFiles(path6.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 code = withoutComments(source);
   if (COMPONENT.test(file)) {
     found.unknown = `${shown(file)} is a component, which can use others that it does not import`;
   }
-  const uncheckable = findUncheckableImports(source)[0];
-  const runtime = RUNTIME_PATHS.exec(source);
+  const uncheckable = findUncheckableImports(code)[0];
+  const runtime = RUNTIME_PATHS.exec(code);
   if (uncheckable !== void 0) {
     found.unknown = `${shown(file)}:${uncheckable} imports a module whose path is not written out`;
     found.computed = true;
   } else if (runtime !== null) {
     found.unknown = `${shown(file)} uses ${runtime[0]}, which can reach files that no import names`;
   }
+  const 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(
+      const resolved2 = resolveFiles(
         specifier.startsWith("file:") ? new URL(specifier).pathname : specifier
       );
-      if (resolved === null) {
+      if (resolved2.length === 0) {
         found.unknown ??= `${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) {
+      const resolved2 = target(specifier, file);
+      if (resolved2.length === 0) {
         found.unknown ??= `${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`;
@@ -2440,18 +3035,40 @@ function fileEdges(file, context) {
       }
     }
   }
+  if (location !== null) {
+    const reads = LOCATION_READS.exec(code);
+    const reader = [...specifiers].find(
+      (specifier) => !specifier.startsWith(".") && !path6.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`;
+    } 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(path6.resolve(path6.dirname(file), text)).map(realpath));
+    }
   }
   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()];
@@ -2467,8 +3084,43 @@ function affectedInputs(manifest, input) {
     return toPosix2(relative);
   };
   const shown = (file) => toPosix2(path6.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 = fs6.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 = path6.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 closure = (start, strict) => {
     const seen = /* @__PURE__ */ new Set([start]);
     const queue = [start];
@@ -2509,9 +3161,17 @@ function affectedInputs(manifest, input) {
       }
       for (const match of fs6.readFileSync(loaded, "utf8").matchAll(QUOTED)) {
         const text = match[2].replace(/^<rootDir>\//, "");
-        const found = resolveFile(path6.resolve(path6.dirname(loaded), text), false) ?? resolveFile(path6.resolve(dir, text), false);
-        if (found !== null && !text.includes("*") && isCompared(found)) {
-          named.push(realpath(found));
+        const here = resolveFiles(path6.resolve(path6.dirname(loaded), text), false, false);
+        const candidates = here.length > 0 ? here : resolveFiles(path6.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));
+          }
         }
       }
     }
@@ -2579,7 +3239,22 @@ function affectedInputs(manifest, input) {
       files: found.files
     };
   }
-  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, path6.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,6 +3290,9 @@ 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 };
@@ -2671,19 +3349,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) {
       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(path6.resolve(path6.dirname(file), text), false);
+        const found = here.length > 0 ? here : resolveFiles(path6.resolve(dir, text), false);
+        for (const one of text.includes("*") ? [] : found) {
+          if (!SCRIPT.test(one)) {
+            naming.add(realpath(one));
           }
-          add(found);
+          add(one);
         }
       }
     }
@@ -2740,286 +3415,420 @@ 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 {
-      out += char;
+      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 {
+      end += 1;
     }
   }
-  return out;
+  return end;
 }
-
-// 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(/^\.\//, "");
-}
-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 = path6.join(dir, "package.json");
+  return configs.runner === "jest" && configs.files.length === 1 && fs6.existsSync(file) ? [{ file, text: fs6.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 partsOf(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 = path6.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 path6.resolve(here, stringValue(url[1] ?? url[2]));
+  }
+  const call = /^(?:path\.)?(?:resolve|join)\s*\(/.exec(value);
+  if (call !== null) {
+    const found = partsOf(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 : path6.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 fs6.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
+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(path6.relative(dir, file));
+  const under = (base, rest) => rest === "" ? `${base}/` : path6.join(base, rest);
+  const named = (prefix, target) => {
+    const alias = aliases.find((candidate) => prefix.startsWith(candidate.prefix));
+    if (alias === void 0) {
+      return false;
+    }
+    const full = alias.target + prefix.slice(alias.prefix.length);
+    const slash = full === "" || full.endsWith("/");
+    return path6.resolve(dir, full) === path6.resolve(target) && slash === target.endsWith("/");
   };
-  const files = /* @__PURE__ */ new Map();
-  for (const [file, result] of Object.entries(input.report.files ?? {})) {
-    files.set(normalizePath(file), result);
+  const advice = (prefix, target) => {
+    const relative = toPosix2(path6.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) ? partsOf(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 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();
+          }
+        }
+      } else {
+        const entry = property(part);
+        if (entry === null) {
+          return unreadableAlias2();
+        }
+        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`;
+    };
+    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 : partsOf(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;
+        }
+        const entry = property(part);
+        if (entry === null) {
+          reasons.push(unreadable);
+          continue;
+        }
+        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(path6.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);
+        }
+      }
+    }
   }
-  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)"
-      });
+  const tsconfigs = input.compiler.filter(({ file }) => /^[jt]sconfig/.test(path6.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 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"
-      });
+    const plain2 = withoutComments(text);
+    const name = path6.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 = partsOf(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;
     }
-    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"
-      });
+    const paths = /"paths"\s*:\s*/.exec(plain2);
+    if (paths === null || !swc && input.testRunner === "jest") {
       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;
-      }
+    const at = paths.index + paths[0].length;
+    const found = plain2[at] === "{" ? partsOf(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;
     }
-    if (!locationsValid) {
+    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 claim = (field, entries, noun, accept) => {
-      const claimed = /* @__PURE__ */ new Set();
-      if (!Array.isArray(entries)) {
-        return claimed;
+    const base = path6.resolve(path6.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;
       }
-      entries.forEach((entry, index) => {
-        if (!isUsableEquivalentMutant(entry)) {
-          return;
-        }
-        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
-        const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
-        if (entry.occurrence === void 0 && group.length > 1) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
-          });
-          return;
-        }
-        const target = group[(entry.occurrence ?? 1) - 1];
-        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
-        if (!target || refusal !== null) {
-          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
-          return;
-        }
-        if (claimed.has(target)) {
-          violations.push({
-            file: MANIFEST_FILE,
-            message: `${at}: another ${noun} already covers this mutant`
-          });
-          return;
-        }
-        claimed.add(target);
-      });
-      return claimed;
-    };
-    const allowed = claim(
-      "equivalentMutants",
-      gate.equivalentMutants,
-      "allowance",
-      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
-    );
-    const expected = claim(
-      "expectedTimeouts",
-      gate.expectedTimeouts,
-      "entry",
-      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
-    );
-    for (const entry of located) {
-      const { mutant } = entry;
-      summary.total += 1;
-      if (DETECTED.has(mutant.status)) {
-        summary.detected += 1;
-        if (mutant.status === "Timeout") {
-          summary.timeout += 1;
-          if (expected.has(entry)) {
-            summary.expectedTimeout += 1;
-          } else {
-            unexpectedTimeouts.push(describeMutant(gate.path, entry));
-          }
-        }
-      } else if (NOT_EVALUABLE.has(mutant.status)) {
-        summary.notEvaluable += 1;
-      } else if (SURVIVED.has(mutant.status)) {
-        if (allowed.has(entry)) {
-          summary.allowed += 1;
-          continue;
-        }
-        summary.unallowed += 1;
-        survivors.push(describeMutant(gate.path, entry));
-      } else {
-        violations.push({
-          file: gate.path,
-          line: mutant.location.start.line,
-          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
-        });
+      const list = entry.value.startsWith("[") ? partsOf(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("*") && path6.resolve(base, target).split(path6.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)));
       }
     }
   }
-  if (summary.total === 0) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: "no mutants were evaluated (the mutation test ran on nothing)"
-    });
-  }
-  const maxTimeouts = input.maxTimeouts ?? 0;
-  if (unexpectedTimeouts.length > maxTimeouts) {
-    violations.push({
-      file: MANIFEST_FILE,
-      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
-    });
-  }
-  return { violations, survivors, unexpectedTimeouts, summary };
-}
-function formatSurvivor(survivor) {
-  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
-  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
-}
-function formatSummary(summary) {
-  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+  return reasons.length === 0 ? null : [...new Set(reasons)].join("; ");
 }
 
+// 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";
 function reportPathOf(manifest, override) {
   return path7.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
 }
@@ -3124,7 +3933,7 @@ function loadStrykerConfig(manifest, config) {
       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 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,}) + ${JSON.stringify(CONFIG_MARK)});`;
   const result = spawnSync2(process.execPath, ["--input-type=module", "--eval", script], {
     cwd: manifest.dir,
     encoding: "utf8",
@@ -3177,7 +3986,13 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   const loaded = loadStrykerConfig(manifest, config);
   const options = incrementalOptions(loaded, strykerArgs);
   const base = fs8.realpathSync(manifest.dir);
-  const configs = () => runnerConfigs(base, config, loaded ?? {});
+  const checkersArg = strykerArgs.some(
+    (arg) => arg === "--checkers" || arg.startsWith("--checkers=")
+  );
+  const configs = () => runnerConfigs(base, config, {
+    ...loaded ?? {},
+    ...checkersArg ? { checkers: ["--checkers"] } : {}
+  });
   const decision = {
     incremental: false,
     incrementalFile: null,
@@ -3207,12 +4022,24 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
   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) => path8.resolve(base, file));
+  const ignores = strykerIgnores(loaded);
+  const read2 = (file) => {
+    const relative = path8.relative(base, file);
+    const inside = !relative.startsWith("..") && !path8.isAbsolute(relative);
+    return !reports.includes(file) && !(inside && ignores(relative.split(path8.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;
+        if (!("files" in found)) {
+          decision.scope = found;
+          return null;
+        }
+        const files = new Set([...found.files].filter(read2));
+        decision.scope = { files: files.size };
+        return files;
       } catch (error) {
         decision.scope = { every: error.message };
         return null;
@@ -3227,7 +4054,8 @@ function decideReuse(manifest, config, strykerArgs, part, affected) {
           incrementalFile,
           recordFile,
           path8.resolve(base, options.tempDirName),
-          path8.resolve(base, manifest.settings.strykerReportFile)
+          path8.resolve(base, manifest.settings.strykerReportFile),
+          ...reports
         ],
         args: comparableArgs(strykerArgs)
       }));
@@ -3260,14 +4088,18 @@ 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;
+      }
     } 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,7 +4111,7 @@ 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,
@@ -3323,7 +4155,7 @@ 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;
@@ -3337,34 +4169,46 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
   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(
+      ({
+        ranges,
+        rerun: timedOut,
+        expected
+      } = timeoutRanges(
         JSON.parse(fs8.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)}`);
+    }
   }
   return {
     // Every gate is run again: the same as a run of every mutant.
@@ -3377,8 +4221,8 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
         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)}
@@ -3387,7 +4231,7 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       }
     }
   };
-  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 +4239,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;
       }
@@ -3417,7 +4261,7 @@ function guardIncremental(manifest, config, strykerArgs, part, affected) {
       }
       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;