@t09tanaka/test-gates 0.3.2 → 0.3.4

package/dist/cli.js

@@ -1,18 +1,29 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // src/core/args.ts
 var COMMANDS = ["check", "mutation", "mutation-result", "selfcheck", "lcov"];
 var UsageError = class extends Error {
 };
-var VALUE_OPTIONS = ["--dir", "--report", "--file"];
+var VALUE_OPTIONS = ["--dir", "--report", "--file", "--gate", "--shard", "--jobs"];
+function parseShard(value) {
+  const match = /^([1-9]\d*)\/([1-9]\d*)$/.exec(value);
+  const index = Number(match?.[1]);
+  const total = Number(match?.[2]);
+  if (!Number.isSafeInteger(total) || index > total) {
+    throw new UsageError(
+      `--shard needs <index>/<total> with 1 <= index <= total (for example 2/4), got ${value}`
+    );
+  }
+  return { index, total };
+}
 var OPTIONS_BY_COMMAND = {
   check: ["--dir"],
-  mutation: ["--dir"],
+  mutation: ["--dir", "--gate"],
   "mutation-result": ["--dir", "--report"],
-  selfcheck: ["--dir", "--all", "--first"],
+  selfcheck: ["--dir", "--all", "--first", "--gate", "--shard", "--quick", "--jobs"],
   lcov: ["--dir", "--file"]
 };
 function consume(parsed, argv, index, allowed) {
@@ -41,13 +52,31 @@ function consume(parsed, argv, index, allowed) {
       if (value === void 0 || value === "") {
         throw new UsageError(`${name} needs a value`);
       }
-      const key = name.slice(2);
-      parsed[key] = value;
+      if (name === "--gate") {
+        parsed.gates.push(value);
+      } else if (name === "--jobs") {
+        if (!/^[1-9]\d{0,2}$/.test(value)) {
+          throw new UsageError(`--jobs needs a number from 1 to 999, got ${value}`);
+        }
+        parsed.jobs = Number(value);
+      } else if (name === "--shard") {
+        if (parsed.shard !== null) {
+          throw new UsageError("--shard can be given only once");
+        }
+        parsed.shard = parseShard(value);
+      } else {
+        const key = name.slice(2);
+        parsed[key] = value;
+      }
       return equals !== -1 ? next : next + 1;
     }
     if (equals !== -1) {
       throw new UsageError(`${name} does not take a value`);
     }
+    if (name === "--quick") {
+      parsed.quick = true;
+      return next;
+    }
     const mode = name === "--all" ? "all" : "first";
     if (parsed.mode !== null && parsed.mode !== mode) {
       throw new UsageError("--all and --first cannot be combined");
@@ -72,6 +101,10 @@ function parseArgs(argv) {
     report: null,
     file: null,
     mode: null,
+    gates: [],
+    shard: null,
+    quick: false,
+    jobs: null,
     rest: []
   };
   let index = 0;
@@ -87,6 +120,23 @@ function parseArgs(argv) {
   while (index < argv.length) {
     index = consume(parsed, argv, index, allowed);
   }
+  const selections = [
+    parsed.mode === null ? null : `--${parsed.mode}`,
+    parsed.gates.length > 0 ? "--gate" : null,
+    parsed.shard === null ? null : "--shard"
+  ].filter((option) => option !== null);
+  if (selections.length > 1) {
+    throw new UsageError(`${selections.join(" and ")} cannot be combined`);
+  }
+  const misplaced = parsed.rest.find((arg) => /^--(gate|shard|quick|jobs)(=|$)/.test(arg));
+  if (parsed.command === "selfcheck" && misplaced !== void 0) {
+    throw new UsageError(
+      `${misplaced.split("=")[0]} after "--" would go to the gate command. Write it before "--"`
+    );
+  }
+  if (parsed.rest.some((arg) => arg === "--gate" || arg.startsWith("--gate="))) {
+    throw new UsageError('--gate after "--" would go to Stryker. Write it before "--"');
+  }
   if (parsed.command === "selfcheck" && parsed.rest.length === 0 && argv.includes("--")) {
     throw new UsageError('"--" must be followed by the gate command');
   }
@@ -559,19 +609,22 @@ function vitestCoverageViolation(input) {
 // src/fs.ts
 import fs from "fs";
 import path from "path";
-function existsExact(rootDir, relativePath, kind = "file") {
+function existsExact(rootDir, relativePath, kind = "file", listing = /* @__PURE__ */ new Map()) {
   let current = rootDir;
   for (const segment of relativePath.split("/")) {
     if (segment === "" || segment === ".") {
       continue;
     }
-    let entries;
-    try {
-      entries = fs.readdirSync(current);
-    } catch {
-      return false;
+    let entries = listing.get(current);
+    if (entries === void 0) {
+      try {
+        entries = fs.readdirSync(current);
+      } catch {
+        entries = null;
+      }
+      listing.set(current, entries);
     }
-    if (!entries.includes(segment)) {
+    if (entries === null || !entries.includes(segment)) {
       return false;
     }
     current = path.join(current, segment);
@@ -927,6 +980,7 @@ function resolveSettings(raw) {
 
 // src/core/selfcheck.ts
 var EXCLUDE_ENV = "TEST_GATES_EXCLUDE_SPEC";
+var EXCLUDE_ALL_ENV = "TEST_GATES_EXCLUDE_SPECS";
 var THRESHOLD_MESSAGE = /threshold|coverage data for/i;
 function escapeRegExp2(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -946,6 +1000,194 @@ function judgeSelfcheck(input) {
   const reported = output.split("\n").some((line) => line.includes(gatePath) && THRESHOLD_MESSAGE.test(line));
   return reported ? null : `the gate failed (exit ${status}) but not on the coverage threshold of ${gatePath}. It may be failing for another reason`;
 }
+function selectControls(input) {
+  const { gates, mode, only, shard } = input;
+  if (only.length > 0) {
+    const unknown = only.filter((path11) => !gates.includes(path11));
+    if (unknown.length > 0) {
+      return {
+        error: `--gate ${unknown.join(", ")}: not a gate of test-gates.json (write the path as it is written there)`
+      };
+    }
+    return { selected: gates.filter((path11) => only.includes(path11)) };
+  }
+  if (shard !== null) {
+    if (shard.total > gates.length) {
+      return {
+        error: `--shard ${shard.index}/${shard.total}: there are only ${gates.length} gate(s). A part without a gate would pass without checking anything`
+      };
+    }
+    return {
+      selected: gates.filter((_path, position) => position % shard.total === shard.index - 1)
+    };
+  }
+  return { selected: mode === "first" ? gates.slice(0, 1) : gates };
+}
+var VERIFIED_RUNS = [
+  { runner: "jest", versions: ["30.5"], provider: "babel", pools: ["default"] },
+  { runner: "vitest", versions: ["3.2"], provider: "istanbul", pools: ["forks", "threads"] }
+];
+function minorOf(version) {
+  const match = /^(\d+\.\d+)\./.exec(version);
+  return match === null ? version : match[1];
+}
+function unverifiedVersion(runner, version, table = VERIFIED_RUNS) {
+  const known = table.find((entry) => entry.runner === runner);
+  if (known === void 0) {
+    return `the shared run is not verified with ${runner}`;
+  }
+  return known.versions.includes(minorOf(version)) ? null : `the shared run is verified with ${runner} ${known.versions.join(", ")}, not with ${version}`;
+}
+var SURROUNDINGS = /\bprocess\s*\.\s*env\b|\bimport\.meta\.env\b|['"`](?:node:)?(?:fs|fs\/promises|child_process|worker_threads|net|http|https)['"`]/;
+function inCi(env) {
+  const ci = (env.CI ?? "").trim().toLowerCase();
+  return ci !== "" && ci !== "false" && ci !== "0";
+}
+function quickRefused(env) {
+  return inCi(env) ? "--quick is refused in CI (the variable CI is set): what it reports as holding is not the final check. Run selfcheck without it, with --shard to split it over jobs" : null;
+}
+function gateRunRefused(env) {
+  return inCi(env) ? "--gate is refused in CI (the variable CI is set): a mutation run of a part of the gates is not the final check. Run mutation without it" : null;
+}
+function gateRunCaveat(judged, all) {
+  return `. Only ${judged} of ${all} gate(s) were run and judged (--gate), and a change in one gate can make a mutant of another survive: run without --gate for the final check`;
+}
+function quickCaveat(shared) {
+  return shared === 0 ? "" : `. Of the controls that held, ${shared} came from one shared run (--quick), which a spec that depends on other specs can make differ from a run per gate: run without --quick for the final check`;
+}
+function sharedRunPrecheck(input) {
+  const reaching = input.specs.find((spec) => SURROUNDINGS.test(spec.source));
+  if (reaching !== void 0) {
+    return `${reaching.path} reads the environment or files, so what it executes may depend on which other specs ran`;
+  }
+  const runner = ["jest", "vitest"].find((name) => name === input.program);
+  if (runner === void 0) {
+    return null;
+  }
+  if (input.version !== null) {
+    const unverified = unverifiedVersion(runner, input.version);
+    if (unverified !== null) {
+      return unverified;
+    }
+  }
+  if (input.configSource === null) {
+    return null;
+  }
+  const helper = runner === "jest" ? "createJestGatesConfig" : "createVitestGatesConfig";
+  if (!input.configSource.includes(helper)) {
+    return `the gate config does not use ${helper}`;
+  }
+  if (runner === "vitest" && !input.configSource.includes("istanbul")) {
+    return "Vitest measures with the v8 provider; the shared run needs coverageProvider: 'istanbul'";
+  }
+  return null;
+}
+function unverifiedRun(run) {
+  if (run.problem !== null) {
+    return run.problem;
+  }
+  const version = unverifiedVersion(run.runner, run.version);
+  if (version !== null) {
+    return version;
+  }
+  const known = VERIFIED_RUNS.find(
+    (entry) => entry.runner === run.runner
+  );
+  if (known.provider !== run.provider) {
+    return `the shared run is not verified with the coverage provider ${run.provider}`;
+  }
+  if (!known.pools.includes(run.pool)) {
+    return `the shared run is not verified with the pool ${run.pool}`;
+  }
+  if (!run.isolate) {
+    return "the shared run is not verified with spec files that share their modules (isolate: false)";
+  }
+  if (run.projects !== 1) {
+    return `the shared run is not verified with ${run.projects} projects in one run`;
+  }
+  return null;
+}
+function sorted(counts) {
+  return [...counts].sort((left, right) => left - right);
+}
+function same(left, right) {
+  return left.every((count, index) => count === right[index]);
+}
+function contained(part, whole) {
+  const left = sorted(whole);
+  return sorted(part).every((count) => {
+    const position = left.indexOf(count);
+    if (position === -1) {
+      return false;
+    }
+    left.splice(position, 1);
+    return true;
+  });
+}
+function accountedFor(total, parts) {
+  const first = parts[0];
+  if (total === void 0 || first === void 0) {
+    return "unknown";
+  }
+  const lined = parts.every(
+    (part) => part.s.length === first.s.length && part.f.length === first.f.length && part.b.length === first.b.length
+  );
+  if (!lined || total.f.length !== first.f.length || total.b.length !== first.b.length) {
+    return "unknown";
+  }
+  const sum = (key) => first[key].map(
+    (_count, index) => parts.reduce((added, part) => added + part[key][index], 0)
+  );
+  return same(sorted(total.f), sorted(sum("f"))) && same(sorted(total.b), sorted(sum("b"))) && contained(total.s, sum("s")) ? "yes" : "no";
+}
+function planControls(input) {
+  const { all, targets, run, notes, totals } = input;
+  const everyoneAlone = (reason) => ({ together: [], alone: targets, reason });
+  if (input.failurePattern && !input.failurePattern.includes("{gate}")) {
+    return everyoneAlone("settings.selfcheck.failurePattern does not contain {gate}");
+  }
+  if (run === null || notes === null || totals === null) {
+    return everyoneAlone(
+      "the gate run left no notes (the gate config does not use the helpers of this package, or Vitest measures with the v8 provider)"
+    );
+  }
+  const unverified = unverifiedRun(run);
+  if (unverified !== null) {
+    return everyoneAlone(unverified);
+  }
+  const silent = all.find((gate) => !notes.some((note) => note.spec === gate.specFile));
+  if (silent !== void 0) {
+    return everyoneAlone(`the gate run left no note for the spec of ${silent.path}`);
+  }
+  const partsOf = (gate) => notes.flatMap((note) => gate.file in note.files ? [note.files[gate.file]] : []);
+  const short = all.find((gate) => accountedFor(totals[gate.file], partsOf(gate)) === "no");
+  if (short !== void 0) {
+    return everyoneAlone(
+      `the notes of the specs do not add up to what the runner counted for ${short.path}`
+    );
+  }
+  const together = targets.filter((target) => {
+    const gate = all.find((candidate) => candidate.path === target);
+    if (gate === void 0) {
+      return false;
+    }
+    if (all.some((other) => other.path !== gate.path && other.path.includes(gate.path))) {
+      return false;
+    }
+    if (accountedFor(totals[gate.file], partsOf(gate)) !== "yes") {
+      return false;
+    }
+    const touching = notes.filter((note) => {
+      const counters = note.files[gate.file];
+      return counters !== void 0 && [...counters.s, ...counters.f, ...counters.b].some((count) => count !== 0);
+    }).map((note) => note.spec);
+    return touching.length === 1 && touching.includes(gate.specFile);
+  });
+  if (together.length < 2) {
+    return everyoneAlone("fewer than two gates are touched by their own spec only");
+  }
+  return { together, alone: targets.filter((target) => !together.includes(target)), reason: null };
+}
 
 // src/load.ts
 function readManifest(dir) {
@@ -970,9 +1212,12 @@ function readManifest(dir) {
     }
     throw error;
   }
+  const listing = /* @__PURE__ */ new Map();
   const gates = parsed.gates.map((gate) => {
     const specCandidates = specCandidatesFor(gate.path, settings);
-    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    const existingSpecs = specCandidates.filter(
+      (candidate) => existsExact(absoluteDir, candidate, "file", listing)
+    );
     return {
       ...gate,
       specCandidates,
@@ -1020,6 +1265,7 @@ function isPlainRelativePath(file) {
 function checkGates(manifest) {
   const { dir, settings } = manifest;
   const violations = [...manifest.violations];
+  const listing = /* @__PURE__ */ new Map();
   for (const gate of manifest.gates) {
     if (!isPlainRelativePath(gate.path)) {
       violations.push({
@@ -1047,7 +1293,7 @@ function checkGates(manifest) {
         });
       }
     }
-    if (!existsExact(dir, gate.path)) {
+    if (!existsExact(dir, gate.path, "file", listing)) {
       violations.push({
         file: gate.path,
         message: "file not found (the check is case-sensitive)"
@@ -1076,7 +1322,7 @@ function checkGates(manifest) {
     violations.push(...scanSpecSource(gate.path, specPath, readText(dir, specPath), settings));
   }
   for (const candidate of manifest.candidates) {
-    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any")) {
+    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any", listing)) {
       violations.push({
         file: MANIFEST_FILE,
         message: `${candidate.path}: candidate not found. Remove it, or fix the path`
@@ -1167,9 +1413,9 @@ function parseLcov(text, rootDir) {
     const line = rawLine.trim();
     if (line.startsWith("SF:")) {
       closeRecord();
-      const path7 = normalizePath(line.slice(3), rootDir);
-      const file = files.get(path7) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
-      files.set(path7, file);
+      const path11 = normalizePath(line.slice(3), rootDir);
+      const file = files.get(path11) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path11, file);
       record = { file, hasDa: false, found: 0, hit: 0 };
     } else if (line === "end_of_record") {
       closeRecord();
@@ -1264,8 +1510,9 @@ function runLcov(dir, fileOption, io2) {
     return 1;
   }
   const violations = [...manifest.violations];
+  const listing = /* @__PURE__ */ new Map();
   const existing = manifest.gates.filter((gate) => {
-    const exists = existsExact(manifest.dir, gate.path);
+    const exists = existsExact(manifest.dir, gate.path, "file", listing);
     if (!exists) {
       violations.push({
         file: gate.path,
@@ -1298,12 +1545,437 @@ function runLcov(dir, fileOption, io2) {
 }
 
 // src/commands/mutation.ts
-import { spawnSync } from "child_process";
-import fs6 from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import fs7 from "fs";
+import path7 from "path";
+import { pathToFileURL } from "url";
 
-// src/commands/mutation-result.ts
+// src/core/reuse-guard.ts
+var RECORD_FORMAT = 1;
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function parseRecord(value) {
+  const { format, incremental, snapshot } = 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 (!Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
+    return null;
+  }
+  if (!isStringRecord(environment) || !isStringRecord(files)) {
+    return null;
+  }
+  return { format, incremental, snapshot: { mode, environment, args, files } };
+}
+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 refuseReuse(input) {
+  if (input.record === void 0) {
+    return "there is no record of the run that wrote the incremental file";
+  }
+  const record = parseRecord(input.record);
+  if (record === null) {
+    return "the record of the last run is not one this version can read";
+  }
+  if (record.incremental !== input.incremental) {
+    return "the incremental file is not the one the last recorded run wrote";
+  }
+  const before = record.snapshot;
+  const now = input.snapshot;
+  if (before.mode !== now.mode) {
+    return `the files are listed in another way than in the last run (${before.mode}, now ${now.mode})`;
+  }
+  const environment = differingKeys(before.environment, now.environment);
+  if (environment.length > 0) {
+    const changes = environment.map(
+      (key) => `${key} ${before.environment[key] ?? "none"} \u2192 ${now.environment[key] ?? "none"}`
+    );
+    return `the tools changed since the last run: ${listed(changes)}`;
+  }
+  if (JSON.stringify(before.args) !== JSON.stringify(now.args)) {
+    return "the arguments for Stryker are not those of the last run";
+  }
+  const files = differingKeys(before.files, now.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");
+}
+
+// src/snapshot.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
 import fs5 from "fs";
+import { createRequire } from "module";
+import os from "os";
 import path5 from "path";
+var SnapshotError = class extends Error {
+};
+var TOOLS = [
+  "@stryker-mutator/core",
+  "@stryker-mutator/jest-runner",
+  "@stryker-mutator/vitest-runner",
+  "@stryker-mutator/typescript-checker",
+  "jest",
+  "babel-jest",
+  "ts-jest",
+  "@swc/jest",
+  "vitest",
+  "vite",
+  "@vitest/coverage-istanbul",
+  "@vitest/coverage-v8",
+  "typescript"
+];
+var INSTALL_MARKERS = [
+  ".package-lock.json",
+  ".yarn-integrity",
+  ".yarn-state.yml",
+  ".modules.yaml"
+];
+var LOCK_FILES = [
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lock",
+  "bun.lockb"
+];
+var NEVER = ["node_modules", ".git"];
+var SCAN_LIMIT = 8 * 1024 * 1024;
+var UPWARD = /(['"`])((?:[^'"`\n]*\/)?\.\.(?:\/[^'"`\n]*)?)\1/g;
+function hashOf(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hashFile(file) {
+  try {
+    return hashOf(fs5.readFileSync(file));
+  } catch {
+    return null;
+  }
+}
+function isInside(parent, child) {
+  const relative = path5.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function toPosix(file) {
+  return file.split(path5.sep).join("/");
+}
+function git(cwd, args) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 * 1024 });
+  return result.error || result.status !== 0 ? null : result.stdout;
+}
+function gitLister(root) {
+  return (directory, recursive) => {
+    const relative = toPosix(path5.relative(root, directory));
+    const pattern = recursive ? `${relative === "" ? "" : `${relative}/`}**` : `${relative === "" ? "" : `${relative}/`}*`;
+    const listed2 = git(root, [
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      `:(glob)${pattern}`
+    ]);
+    if (listed2 === null) {
+      throw new SnapshotError("git could not list the files");
+    }
+    return listed2.split("\0").filter((file) => file !== "");
+  };
+}
+function walkLister(root) {
+  const walk = (directory, recursive, found) => {
+    for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
+      const file = path5.join(directory, entry.name);
+      if (NEVER.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (recursive) {
+          walk(file, true, found);
+        }
+      } else {
+        found.push(toPosix(path5.relative(root, file)));
+      }
+    }
+    return found;
+  };
+  return (directory, recursive) => walk(directory, recursive, []);
+}
+function upTo(from, to) {
+  const directories = [from];
+  while (directories[directories.length - 1] !== to) {
+    directories.push(path5.dirname(directories[directories.length - 1]));
+  }
+  return directories;
+}
+function declaresWorkspaces(directory) {
+  if (fs5.existsSync(path5.join(directory, "pnpm-workspace.yaml"))) {
+    return true;
+  }
+  try {
+    const manifest = JSON.parse(fs5.readFileSync(path5.join(directory, "package.json"), "utf8"));
+    return manifest.workspaces !== void 0;
+  } catch {
+    return false;
+  }
+}
+function walkRoot(dir) {
+  const candidates = withinBounds(dir);
+  const repository = candidates.find((directory) => fs5.existsSync(path5.join(directory, ".git")));
+  if (repository !== void 0) {
+    return repository;
+  }
+  return candidates.filter(declaresWorkspaces).pop() ?? dir;
+}
+function withinBounds(dir) {
+  let home = null;
+  try {
+    home = fs5.realpathSync(os.homedir());
+  } catch {
+  }
+  return upTo(dir, path5.parse(dir).root).filter(
+    (directory) => directory !== path5.parse(dir).root && (home === null || !isInside(directory, home))
+  );
+}
+function linkedPackages(nodeModules, root) {
+  const found = [];
+  const visit = (directory, depth) => {
+    let entries;
+    try {
+      entries = fs5.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const file = path5.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        let target;
+        try {
+          target = fs5.realpathSync(file);
+        } catch {
+          continue;
+        }
+        if (target.split(path5.sep).includes("node_modules") || !fs5.statSync(target).isDirectory()) {
+          continue;
+        }
+        if (!isInside(root, target)) {
+          throw new SnapshotError(
+            `${file} is a link to a directory outside of what can be listed (${target})`
+          );
+        }
+        found.push(target);
+      } else if (depth === 0 && entry.isDirectory() && entry.name.startsWith("@")) {
+        visit(file, 1);
+      }
+    }
+  };
+  visit(nodeModules, 0);
+  return found;
+}
+function installedVersion(start, name) {
+  let current = start;
+  for (; ; ) {
+    try {
+      const manifest = JSON.parse(
+        fs5.readFileSync(path5.join(current, "node_modules", name, "package.json"), "utf8")
+      );
+      return typeof manifest.version === "string" ? manifest.version : "unknown";
+    } catch {
+      const parent = path5.dirname(current);
+      if (parent === current) {
+        return null;
+      }
+      current = parent;
+    }
+  }
+}
+function ownVersion() {
+  const { version } = createRequire(import.meta.url)("../package.json");
+  return version;
+}
+function takeSnapshot(input) {
+  const dir = fs5.realpathSync(input.dir);
+  const top = git(dir, ["rev-parse", "--show-toplevel"]);
+  let root = top === null ? dir : fs5.realpathSync(top.trim());
+  let lister = gitLister(root);
+  let mode = "git";
+  const manifest = toPosix(path5.relative(root, path5.join(dir, "test-gates.json")));
+  if (top === null || !lister(dir, false).includes(manifest)) {
+    mode = "walk";
+    root = walkRoot(dir);
+    lister = walkLister(root);
+  }
+  const listRoot = root;
+  const list = lister;
+  const walk = walkLister(listRoot);
+  const written = input.written.map((file) => {
+    const target = path5.resolve(dir, file);
+    try {
+      return fs5.realpathSync(target);
+    } catch {
+      return target;
+    }
+  });
+  const swallowing = written.find((target) => isInside(target, path5.join(dir, "test-gates.json")));
+  if (swallowing !== void 0) {
+    throw new SnapshotError(`the run writes to ${swallowing}, which holds test-gates.json`);
+  }
+  const files = /* @__PURE__ */ Object.create(null);
+  const regions = [dir];
+  const queued = new Set(regions);
+  const enqueue = (target, from) => {
+    const directory = isInside(target, dir) && isInside(listRoot, target) ? listRoot : target;
+    if (!isInside(listRoot, directory)) {
+      throw new SnapshotError(
+        `${toPosix(path5.relative(dir, from))} points outside of what can be listed (${directory})`
+      );
+    }
+    if (![...queued].some((region) => isInside(region, directory))) {
+      queued.add(directory);
+      regions.push(directory);
+    }
+  };
+  const follow = (literal, file) => {
+    const fixed = literal.includes("${") ? literal.slice(0, literal.lastIndexOf("/", literal.indexOf("${")) + 1) : literal;
+    if (!fixed.startsWith("../")) {
+      enqueue(listRoot, file);
+      return;
+    }
+    const target = path5.resolve(path5.dirname(file), fixed);
+    let isDirectory = false;
+    try {
+      isDirectory = fs5.statSync(target).isDirectory();
+    } catch {
+    }
+    const directory = isDirectory ? target : path5.dirname(target);
+    if (fs5.existsSync(directory)) {
+      enqueue(directory, file);
+    }
+  };
+  const add = (relative) => {
+    const file = path5.join(listRoot, relative);
+    if (relative in files || written.some((target) => isInside(target, file))) {
+      return;
+    }
+    let stat;
+    try {
+      stat = fs5.lstatSync(file);
+    } catch {
+      files[relative] = "missing";
+      return;
+    }
+    if (stat.isSymbolicLink()) {
+      files[relative] = `link ${fs5.readlinkSync(file)}`;
+      let target;
+      try {
+        target = fs5.realpathSync(file);
+      } catch {
+        return;
+      }
+      enqueue(fs5.statSync(target).isDirectory() ? target : path5.dirname(target), file);
+    } else if (stat.isDirectory()) {
+      files[relative] = "directory";
+      walk(file, true).forEach(add);
+    } else if (!stat.isFile()) {
+      files[relative] = "special";
+    } else {
+      const content = fs5.readFileSync(file);
+      files[relative] = hashOf(content);
+      if (content.length <= SCAN_LIMIT && !content.subarray(0, 8e3).includes(0)) {
+        const text = content.toString("utf8").replace(/\\[\\/]/g, "/");
+        for (const match of text.matchAll(UPWARD)) {
+          follow(match[2], file);
+        }
+      }
+    }
+  };
+  const ancestors = upTo(dir, listRoot).slice(1);
+  for (const directory of ancestors) {
+    list(directory, false).forEach(add);
+  }
+  for (const directory of [dir, ...ancestors]) {
+    for (const linked of linkedPackages(path5.join(directory, "node_modules"), listRoot)) {
+      if (!isInside(linked, dir)) {
+        enqueue(linked, path5.join(directory, "node_modules"));
+      }
+    }
+  }
+  const above = withinBounds(listRoot).slice(1);
+  for (const directory of [dir, ...ancestors, ...above]) {
+    const candidates = [
+      ...INSTALL_MARKERS.map((marker) => path5.join(directory, "node_modules", marker)),
+      ...above.includes(directory) ? LOCK_FILES.map((name) => path5.join(directory, name)) : []
+    ];
+    for (const file of candidates) {
+      const hash = hashFile(file);
+      if (hash !== null) {
+        files[toPosix(path5.relative(listRoot, file))] = hash;
+      }
+    }
+  }
+  for (let position = 0; position < regions.length; position += 1) {
+    list(regions[position], true).forEach(add);
+  }
+  const environment = {
+    "Node.js": process.version,
+    platform: `${process.platform} ${process.arch}`,
+    "test-gates": ownVersion()
+  };
+  for (const name of TOOLS) {
+    const version = installedVersion(dir, name);
+    if (version !== null) {
+      environment[name] = version;
+    }
+  }
+  return {
+    mode,
+    environment,
+    args: input.args,
+    files
+  };
+}
+
+// src/commands/mutation-result.ts
+import fs6 from "fs";
+import path6 from "path";
 
 // src/core/mutation-result.ts
 var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
@@ -1413,11 +2085,11 @@ function judgeMutationReport(input) {
     }
     const located = [];
     const byKey = /* @__PURE__ */ new Map();
-    const sorted = [...result.mutants].sort(
+    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 sorted) {
+    for (const mutant of sorted2) {
       const original = sliceByLocation(normalizeNewlines(source), mutant.location);
       if (original === null) {
         violations.push({
@@ -1553,15 +2225,17 @@ function formatSummary(summary) {
 
 // src/commands/mutation-result.ts
 function reportPathOf(manifest, override) {
-  return path5.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
+  return path6.resolve(manifest.dir, override ?? manifest.settings.strykerReportFile);
 }
-function runMutationResult(dir, reportOverride, io2) {
+function runMutationResult(dir, reportOverride, io2, only = []) {
   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 = path5.relative(manifest.dir, reportPath) || reportPath;
+  const shown = path6.relative(manifest.dir, reportPath) || reportPath;
   let report;
   try {
-    report = JSON.parse(fs5.readFileSync(reportPath, "utf8"));
+    report = JSON.parse(fs6.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?`
@@ -1573,12 +2247,12 @@ function runMutationResult(dir, reportOverride, io2) {
     return 1;
   }
   const verdict = judgeMutationReport({
-    gates: manifest.gates,
+    gates,
     report,
     maxTimeouts: manifest.settings.maxTimeouts,
     readSource: (gatePath) => {
       try {
-        return fs5.readFileSync(path5.join(manifest.dir, gatePath), "utf8");
+        return fs6.readFileSync(path6.join(manifest.dir, gatePath), "utf8");
       } catch {
         return void 0;
       }
@@ -1586,7 +2260,7 @@ function runMutationResult(dir, reportOverride, io2) {
   });
   const summary = formatSummary(verdict.summary);
   if (verdict.violations.length === 0 && verdict.survivors.length === 0) {
-    io2.out(`test-gates mutation: OK (${summary})`);
+    io2.out(`test-gates mutation: OK (${summary})${caveat}`);
     return 0;
   }
   if (verdict.survivors.length > 0) {
@@ -1638,13 +2312,133 @@ function runMutationResult(dir, reportOverride, io2) {
   if (verdict.violations.length > 0) {
     printViolations(io2, "mutation", verdict.violations);
   }
-  io2.err(`test-gates mutation: FAILED (${summary})`);
+  io2.err(`test-gates mutation: FAILED (${summary})${caveat}`);
   return 1;
 }
 
 // src/commands/mutation.ts
-function runMutation(dir, strykerArgs, io2) {
+var CONFIG_MARK = "\0test-gates-stryker-config\0";
+function loadStrykerConfig(manifest, config) {
+  const file = path7.resolve(manifest.dir, config);
+  if (file.endsWith(".json")) {
+    try {
+      return JSON.parse(fs7.readFileSync(file, "utf8"));
+    } catch {
+      return void 0;
+    }
+  }
+  const script = `const loaded = await import(${JSON.stringify(pathToFileURL(file).href)});const config = loaded.default?.default ?? loaded.default ?? loaded;process.stdout.write(${JSON.stringify(CONFIG_MARK)} + JSON.stringify({incremental: config.incremental, force: config.force,incrementalFile: config.incrementalFile, tempDirName: config.tempDirName,}) + ${JSON.stringify(CONFIG_MARK)});`;
+  const result = spawnSync2(process.execPath, ["--input-type=module", "--eval", script], {
+    cwd: manifest.dir,
+    encoding: "utf8",
+    timeout: 6e4
+  });
+  const printed = result.stdout?.split(CONFIG_MARK)[1];
+  if (result.status !== 0 || printed === void 0) {
+    return void 0;
+  }
+  return JSON.parse(printed);
+}
+function modifiedAt(file) {
+  try {
+    const stat = fs7.statSync(file, { bigint: true });
+    return `${stat.mtimeNs} ${stat.ino}`;
+  } catch {
+    return null;
+  }
+}
+function guardRecordPath(incrementalFile) {
+  return `${incrementalFile}.test-gates.json`;
+}
+function guardIncremental(manifest, config, strykerArgs, part) {
+  const nothing = { force: null, record: () => void 0 };
+  const loaded = loadStrykerConfig(manifest, config);
+  const options = incrementalOptions(loaded, strykerArgs);
+  if (loaded !== void 0 && !options.incremental) {
+    return nothing;
+  }
+  const base = fs7.realpathSync(manifest.dir);
+  const incrementalFile = path7.resolve(base, options.incrementalFile);
+  const recordFile = guardRecordPath(incrementalFile);
+  let snapshot = null;
+  let failure = "the Stryker config could not be loaded to see where the incremental file is";
+  if (loaded !== void 0) {
+    try {
+      snapshot = takeSnapshot({
+        dir: manifest.dir,
+        written: [
+          incrementalFile,
+          recordFile,
+          path7.resolve(base, options.tempDirName),
+          path7.resolve(base, manifest.settings.strykerReportFile)
+        ],
+        args: comparableArgs(strykerArgs)
+      });
+    } catch (error) {
+      failure = `the files the run depends on could not be listed (${error.message})`;
+    }
+  }
+  let force = null;
+  const incremental = hashFile(incrementalFile);
+  if (part) {
+    fs7.rmSync(recordFile, { force: true });
+    return {
+      force: incremental !== null && !options.force ? "with --gate nothing is taken over from an earlier run" : null,
+      record: () => void 0
+    };
+  }
+  if (incremental !== null && !options.force) {
+    if (snapshot === null) {
+      force = failure;
+    } else {
+      let record;
+      try {
+        record = JSON.parse(fs7.readFileSync(recordFile, "utf8"));
+      } catch {
+        record = void 0;
+      }
+      force = refuseReuse({ record, incremental, snapshot });
+    }
+  }
+  fs7.rmSync(recordFile, { force: true });
+  const before = modifiedAt(incrementalFile);
+  return {
+    force,
+    record: () => {
+      const written = hashFile(incrementalFile);
+      if (snapshot === null || written === null || modifiedAt(incrementalFile) === before) {
+        return;
+      }
+      const record = { format: RECORD_FORMAT, incremental: written, snapshot };
+      try {
+        fs7.writeFileSync(recordFile, `${JSON.stringify(record)}
+`);
+      } catch {
+      }
+    }
+  };
+}
+function runMutation(dir, strykerArgs, io2, only = []) {
+  const part = only.length > 0;
+  if (part) {
+    const refused = gateRunRefused(process.env);
+    if (refused !== null) {
+      throw new UsageError(refused);
+    }
+    if (strykerArgs.some((arg) => /^(?:--mutate|-m)(?:=|$)/.test(arg))) {
+      throw new UsageError("--gate and --mutate cannot be combined: --gate sets --mutate itself");
+    }
+  }
   const manifest = readManifest(dir);
+  const chosen = selectControls({
+    gates: manifest.gates.map((gate) => gate.path),
+    mode: "all",
+    only,
+    shard: null
+  });
+  if ("error" in chosen) {
+    throw new UsageError(chosen.error);
+  }
   const config = findStrykerConfig(manifest);
   if (config === null) {
     throw new ManifestError(
@@ -1657,8 +2451,17 @@ function runMutation(dir, strykerArgs, io2) {
       "stryker is not installed in this project (node_modules/.bin/stryker). Add @stryker-mutator/core as a devDependency"
     );
   }
-  fs6.rmSync(reportPathOf(manifest, null), { force: true });
-  const result = spawnSync(stryker, ["run", config, ...strykerArgs], {
+  const reportFile = reportPathOf(manifest, null);
+  fs7.rmSync(reportFile, { force: true });
+  const guard = guardIncremental(manifest, config, strykerArgs, part);
+  if (guard.force !== null) {
+    io2.out(
+      `test-gates mutation: running every mutant again (--force), the results of the last run are not reused: ${guard.force}`
+    );
+  }
+  const guardArgs = guard.force === null ? [] : ["--force"];
+  const partArgs = part ? ["--mutate", chosen.selected.join(",")] : [];
+  const result = spawnSync2(stryker, ["run", config, ...strykerArgs, ...partArgs, ...guardArgs], {
     cwd: manifest.dir,
     stdio: "inherit",
     shell: process.platform === "win32"
@@ -1673,13 +2476,392 @@ function runMutation(dir, strykerArgs, io2) {
     );
     return 1;
   }
-  return runMutationResult(dir, null, io2);
+  guard.record();
+  const status = runMutationResult(dir, null, io2, part ? chosen.selected : []);
+  if (part) {
+    fs7.rmSync(reportFile, { force: true });
+  }
+  return status;
+}
+
+// src/commands/selfcheck.ts
+import { spawn, spawnSync as spawnSync3 } from "child_process";
+import fs10 from "fs";
+import os2 from "os";
+import path10 from "path";
+
+// src/core/jobs.ts
+var SWITCHES = {
+  jest: ["--runInBand", "-i", "--ci"],
+  vitest: ["--no-file-parallelism", "--fileParallelism=false", "--pool=forks", "--pool=threads"]
+};
+var COUNTS = {
+  jest: ["--maxWorkers", "-w"],
+  vitest: ["--maxWorkers", "--minWorkers"]
+};
+var COUNT = /^\d+%?$/;
+function knownCommand(program, args) {
+  const runner = ["jest", "vitest"].find((name) => name === program);
+  if (runner === void 0) {
+    return { stray: program };
+  }
+  if (runner === "vitest" && args[0] !== "run") {
+    return { stray: args[0] ?? 'vitest without "run"' };
+  }
+  const rest = runner === "vitest" ? args.slice(1) : [...args];
+  let configs = 0;
+  for (let arg = rest.shift(); arg !== void 0; arg = rest.shift()) {
+    if (SWITCHES[runner].includes(arg)) {
+      continue;
+    }
+    const equals = arg.indexOf("=");
+    const name = equals === -1 ? arg : arg.slice(0, equals);
+    const value = equals === -1 ? rest.shift() : arg.slice(equals + 1);
+    if (value !== void 0 && (name === "--config" || name === "-c")) {
+      configs += 1;
+    } else if (!COUNTS[runner].includes(name) || !COUNT.test(String(value))) {
+      return { stray: arg };
+    }
+  }
+  return configs === 1 ? { runner } : { stray: configs === 0 ? "no --config" : "two --config" };
+}
+function jobFlags(runner, dir) {
+  return runner === "jest" ? [`--coverageDirectory=${dir}/coverage`, `--cacheDirectory=${dir}/cache`] : [`--coverage.reportsDirectory=${dir}/coverage`, "--no-cache"];
+}
+var REACHES = [
+  "process.",
+  "process?.",
+  "process[",
+  "globalThis",
+  "global.",
+  "global[",
+  "import.meta.env",
+  "Date.now",
+  "Date()",
+  "performance.now",
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "waitFor",
+  "waitUntil",
+  "expect.poll",
+  "retryTimes",
+  "retry:",
+  "fetch(",
+  "WebSocket",
+  "XMLHttpRequest",
+  "navigator",
+  "Atomics",
+  "WeakRef",
+  "FinalizationRegistry",
+  "eval(",
+  "Function("
+];
+var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])/;
+var RUNNER_PACKAGES = ["vitest", "@jest/globals"];
+function reachesOutside(file, trusted) {
+  const dense = file.source.replace(/\s/g, "");
+  const mark = REACHES.find((text) => dense.includes(text));
+  if (mark !== void 0) {
+    return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
+  }
+  if (COMPUTED_LOAD.test(dense)) {
+    return "loads a module whose name is computed";
+  }
+  for (const { specifier, builtin } of file.imports) {
+    if (builtin) {
+      return `imports ${specifier}`;
+    } else if (![...RUNNER_PACKAGES, ...trusted].some(
+      (name) => specifier === name || specifier.startsWith(`${name}/`)
+    )) {
+      return `imports the package ${specifier}, which is not looked into`;
+    }
+  }
+  return null;
+}
+function jobsRefused(input) {
+  if (input.failurePattern) {
+    return "with settings.selfcheck.failurePattern, a run that was disturbed cannot be told from one that was not";
+  }
+  if ("stray" in input.command) {
+    return `the gate command is not known to keep runs at the same time apart: only jest or "vitest run" with --config and options for the number of workers is (found: ${input.command.stray})`;
+  }
+  const helper = input.command.runner === "jest" ? "createJestGatesConfig" : "createVitestGatesConfig";
+  if (input.configSource === null || !input.configSource.includes(helper)) {
+    return `the gate config does not use ${helper}`;
+  }
+  if (input.lost !== null) {
+    return `${input.lost} cannot be followed, so what the gate run loads is not known`;
+  }
+  for (const file of input.files) {
+    const reach = reachesOutside(file, input.trusted);
+    if (reach !== null) {
+      return `${file.path} ${reach}, and may meet what another run is doing`;
+    }
+  }
+  return null;
+}
+var TROUBLE = [
+  "fail",
+  "fails",
+  "failed",
+  "failing",
+  "failure",
+  "failures",
+  "err",
+  "timeout",
+  "timeouts",
+  "timed",
+  "unhandled",
+  "uncaught",
+  "killed",
+  "terminated",
+  "crashed",
+  "aborted",
+  "skipped",
+  "todo",
+  "retry",
+  "retried",
+  "obsolete",
+  "sigkill",
+  "sigterm",
+  "sigabrt",
+  "sigsegv",
+  "sigint"
+];
+var TROUBLE_SIGNS = ["\u2717", "\xD7", "\u2715", "\u2716"];
+function troubled(line) {
+  const words = line.toLowerCase().split(/[^a-z]/);
+  return (
+    // (`TypeError`, `errors`)
+    words.some((word) => TROUBLE.includes(word) || /errors?$/.test(word)) || TROUBLE_SIGNS.some((sign) => line.includes(sign))
+  );
+}
+function plain(line) {
+  return line.split("\x1B[").map((part, index) => index === 0 ? part : part.slice(part.indexOf("m") + 1)).join("").trim();
+}
+var SUMMARY = {
+  jest: {
+    files: "Test Suites:",
+    tests: "Tests:",
+    all: (count) => `${count} passed, ${count} total`
+  },
+  vitest: { files: "Test Files", tests: "Tests", all: (count) => `${count} passed (${count})` }
+};
+function cleanHold(input) {
+  const { output, gatePath, others } = input;
+  if (!input.held || input.signal !== null) {
+    return false;
+  }
+  const lines = output.split("\n").map(plain);
+  const summary = SUMMARY[input.runner];
+  const after = (label) => lines.filter((line) => line.startsWith(label)).map((line) => line.slice(label.length).trim());
+  const files = after(summary.files);
+  const tests = after(summary.tests);
+  const count = (tests[0] ?? "").split(" ")[0];
+  if (files.length !== 1 || files[0] !== summary.all(String(input.specs)) || tests.length !== 1 || !/^\d+$/.test(count) || tests[0] !== summary.all(count)) {
+    return false;
+  }
+  return lines.every((line) => {
+    const lower = line.toLowerCase();
+    if (lower.includes("threshold") || lower.includes("coverage data for")) {
+      return line.includes(gatePath) && !others.some((other) => line.includes(other));
+    }
+    return line.split("|").length >= 5 || // What stands around the names of the project, piece by piece.
+    !input.names.reduce((pieces, name) => pieces.flatMap((piece) => piece.split(name)), [line]).some(troubled);
+  });
+}
+
+// src/touch.ts
+import { createHash as createHash2 } from "crypto";
+import fs8 from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
+var TOUCH_ENV = "TEST_GATES_TOUCH_DIR";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countersOf(coverage) {
+  return {
+    s: Object.values(coverage.s ?? {}),
+    f: Object.values(coverage.f ?? {}),
+    b: Object.values(coverage.b ?? {}).flat()
+  };
+}
+function countersOfAll(coverage) {
+  if (!isObject(coverage)) {
+    return null;
+  }
+  const files = {};
+  for (const [file, counters] of Object.entries(coverage)) {
+    if (!isObject(counters)) {
+      return null;
+    }
+    files[file] = countersOf(counters);
+  }
+  return files;
+}
+function isCounters(value) {
+  return isObject(value) && ["s", "f", "b"].every(
+    (key) => Array.isArray(value[key]) && value[key].every((count) => typeof count === "number")
+  );
+}
+function readNotes(directory) {
+  const read = (file) => {
+    try {
+      return JSON.parse(fs8.readFileSync(path8.join(directory, file), "utf8"));
+    } catch {
+      return null;
+    }
+  };
+  const run = read("run.json");
+  let notes = [];
+  try {
+    for (const name of fs8.readdirSync(path8.join(directory, "specs"))) {
+      const note = read(path8.join("specs", name));
+      if (!isObject(note) || typeof note.spec !== "string" || !isObject(note.files) || !Object.values(note.files).every(isCounters)) {
+        throw new Error("not a note");
+      }
+      notes.push(note);
+    }
+  } catch {
+    notes = null;
+  }
+  return {
+    run: isObject(run) && typeof run.runner === "string" && typeof run.version === "string" && typeof run.provider === "string" && typeof run.pool === "string" && typeof run.isolate === "boolean" && typeof run.projects === "number" && (run.problem === null || typeof run.problem === "string") ? run : null,
+    notes,
+    totals: countersOfAll(read(path8.join("coverage", "coverage-final.json")))
+  };
+}
+
+// src/commands/loaded-files.ts
+import fs9 from "fs";
+import { builtinModules } from "module";
+import path9 from "path";
+var SCRIPT = /\.[cm]?[jt]sx?$/;
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var QUOTED = /(['"`])([^'"`\n]+)\1/g;
+var RUNNER_LOAD = /\b(?:requireActual|requireMock|importActual|importMock|mock|doMock|unstable_mockModule)\(\s*(['"`])([^'"`\n]+)\1/g;
+function isFile(file) {
+  try {
+    return fs9.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveFile(base, directory = true) {
+  const candidates = [
+    base,
+    ...EXTENSIONS.map((extension) => base + extension),
+    // `./fee.js` written in a TypeScript file is `./fee.ts`
+    ...EXTENSIONS.map((extension) => base.replace(/\.[cm]?jsx?$/, extension)),
+    ...directory ? EXTENSIONS.map((extension) => path9.join(base, `index${extension}`)) : []
+  ];
+  return candidates.find(isFile) ?? null;
+}
+function installed(specifier, from) {
+  const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+  for (let current = path9.dirname(from); ; current = path9.dirname(current)) {
+    if (fs9.existsSync(path9.join(current, "node_modules", name))) {
+      return true;
+    }
+    if (current === path9.dirname(current)) {
+      return false;
+    }
+  }
+}
+function loadedFiles(manifest, configFile) {
+  const aliases = manifest.settings.importAliases;
+  const relative = (file) => path9.relative(manifest.dir, file).split(path9.sep).join("/");
+  const target = (specifier, from) => {
+    if (specifier.startsWith(".")) {
+      return resolveFile(path9.resolve(path9.dirname(from), specifier));
+    }
+    const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
+    return alias === void 0 ? null : resolveFile(
+      path9.resolve(manifest.dir, alias.target + specifier.slice(alias.prefix.length))
+    );
+  };
+  const read = (file) => {
+    const source = fs9.readFileSync(file, "utf8");
+    const imports = parseImports(source).filter((ref) => !ref.typeOnly);
+    const specifiers = [
+      .../* @__PURE__ */ new Set([
+        ...imports.map((ref) => ref.module),
+        ...[...source.matchAll(RUNNER_LOAD)].map((match) => match[2])
+      ])
+    ];
+    const strings = [...source.matchAll(QUOTED)].map((match) => match[2]).filter((text) => !specifiers.includes(text));
+    return { source, specifiers, strings };
+  };
+  const named = /* @__PURE__ */ new Set();
+  const configs = configFile === null ? [] : [path9.resolve(manifest.dir, configFile)];
+  const seenConfigs = new Set(configs);
+  const entry = configs[0];
+  for (let file = configs.shift(); file !== void 0; file = configs.shift()) {
+    const { specifiers, strings } = read(file);
+    const paths = strings.filter((text) => file === entry || /^(?:\.|<rootDir>\/)/.test(text));
+    for (const text of paths) {
+      const stripped = text.replace(/^<rootDir>\//, "");
+      const found = resolveFile(path9.resolve(path9.dirname(file), stripped), false) ?? resolveFile(path9.resolve(manifest.dir, stripped), false);
+      if (found !== null && SCRIPT.test(found)) {
+        named.add(found);
+      }
+    }
+    for (const specifier of specifiers.filter((one) => isProjectImport(one, aliases))) {
+      const found = target(specifier, file);
+      if (found !== null && SCRIPT.test(found) && !seenConfigs.has(found)) {
+        seenConfigs.add(found);
+        configs.push(found);
+      }
+    }
+  }
+  const queue = [
+    ...manifest.gates.flatMap(
+      (gate) => gate.existingSpecs.map((spec) => path9.join(manifest.dir, spec))
+    ),
+    ...named
+  ];
+  const seen = new Set(queue);
+  const follow = (found) => {
+    if (SCRIPT.test(found) && !seen.has(found)) {
+      seen.add(found);
+      queue.push(found);
+    }
+  };
+  const files = [];
+  let lost = null;
+  for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+    const { source, specifiers, strings } = read(file);
+    const imports = [];
+    for (const specifier of specifiers) {
+      if (isProjectImport(specifier, aliases)) {
+        const found = target(specifier, file);
+        if (found === null) {
+          lost ??= `${specifier} (imported by ${relative(file)})`;
+        } else {
+          follow(found);
+        }
+      } else if (specifier.startsWith("node:") || builtinModules.includes(specifier)) {
+        imports.push({ specifier, builtin: true });
+      } else if (installed(specifier, file)) {
+        imports.push({ specifier, builtin: false });
+      } else {
+        lost ??= `${specifier} (imported by ${relative(file)})`;
+      }
+    }
+    for (const text of strings.filter((one) => one.startsWith("."))) {
+      const found = resolveFile(path9.resolve(path9.dirname(file), text));
+      if (found !== null) {
+        follow(found);
+      }
+    }
+    files.push({ path: relative(file), source, imports });
+  }
+  return { files, lost };
 }
 
 // src/commands/selfcheck.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import fs7 from "fs";
-import path6 from "path";
 var JEST_CONFIGS = ["js", "cjs", "mjs", "ts", "cts", "mts"].map(
   (extension) => `jest.gates.config.${extension}`
 );
@@ -1690,7 +2872,7 @@ function resolveGateCommand(manifest) {
   if (manifest.settings.gateCommand !== null) {
     return manifest.settings.gateCommand;
   }
-  const exists = (name) => fs7.existsSync(path6.join(manifest.dir, name));
+  const exists = (name) => fs10.existsSync(path10.join(manifest.dir, name));
   const jest = JEST_CONFIGS.find(exists);
   const vitest = VITEST_CONFIGS.find(exists);
   if (jest && vitest) {
@@ -1708,16 +2890,259 @@ function resolveGateCommand(manifest) {
     "no gate config found (jest.gates.config.* / vitest.gates.config.*). Set settings.gateCommand"
   );
 }
-function runSelfcheck(dir, mode, commandOverride, io2) {
+var TOUCH_PREFIX = ".test-gates-touch-";
+function realPath(file) {
+  try {
+    return fs10.realpathSync(file);
+  } catch {
+    return file;
+  }
+}
+function shareOneRun(manifest, targets, runGate) {
+  let touchDir;
+  try {
+    for (const name of fs10.readdirSync(manifest.dir)) {
+      const left = path10.join(manifest.dir, name);
+      if (name.startsWith(TOUCH_PREFIX) && Date.now() - fs10.statSync(left).mtimeMs > 36e5) {
+        fs10.rmSync(left, { recursive: true, force: true });
+      }
+    }
+    touchDir = fs10.mkdtempSync(path10.join(manifest.dir, TOUCH_PREFIX));
+  } catch {
+    return { reason: "the subproject cannot be written to" };
+  }
+  let plan;
+  try {
+    const recorded = runGate({ touchDir });
+    if (recorded.status !== 0) {
+      return { reason: "the gate run with every spec does not pass" };
+    }
+    const base = realPath(manifest.dir);
+    const absolute = (file) => realPath(path10.resolve(base, file));
+    const rekeyed = (files) => Object.fromEntries(Object.entries(files).map(([file, value]) => [absolute(file), value]));
+    const left = readNotes(touchDir);
+    plan = planControls({
+      all: manifest.gates.map((gate) => ({
+        path: gate.path,
+        file: path10.join(base, gate.path),
+        specFile: path10.join(base, gate.spec ?? "")
+      })),
+      targets: targets.map((gate) => gate.path),
+      run: left.run,
+      notes: left.notes?.map((note) => ({ spec: absolute(note.spec), files: rekeyed(note.files) })) ?? null,
+      totals: left.totals === null ? null : rekeyed(left.totals),
+      failurePattern: manifest.settings.selfcheckFailurePattern
+    });
+  } finally {
+    fs10.rmSync(touchDir, { recursive: true, force: true });
+  }
+  if (plan.reason !== null) {
+    return { reason: plan.reason };
+  }
+  const together = plan.together;
+  const gates = targets.filter((gate) => together.includes(gate.path));
+  return { gates, result: runGate({ excludeAll: gates.map((gate) => gate.spec) }) };
+}
+function installedVersion2(start, name) {
+  let current = path10.resolve(start);
+  for (; ; ) {
+    try {
+      const manifest = JSON.parse(
+        fs10.readFileSync(path10.join(current, "node_modules", name, "package.json"), "utf8")
+      );
+      return typeof manifest.version === "string" ? manifest.version : null;
+    } catch {
+      const parent = path10.dirname(current);
+      if (parent === current) {
+        return null;
+      }
+      current = parent;
+    }
+  }
+}
+function gateConfigFile(args) {
+  const joined = args.find((arg) => arg.startsWith("--config="));
+  const position = args.findIndex((arg) => arg === "--config" || arg === "-c");
+  return joined?.slice("--config=".length) ?? (position === -1 ? null : args[position + 1] ?? null);
+}
+function gateConfigSource(manifest, args) {
+  const file = gateConfigFile(args);
+  if (file === null) {
+    return null;
+  }
+  try {
+    return readText(manifest.dir, file);
+  } catch {
+    return null;
+  }
+}
+var JOBS_PREFIX = "test-gates-jobs-";
+async function runAtOnce(manifest, gates, jobs, runner, executable, args) {
+  const results = /* @__PURE__ */ new Map();
+  let root;
+  try {
+    for (const name of fs10.readdirSync(os2.tmpdir())) {
+      const left = path10.join(os2.tmpdir(), name);
+      if (name.startsWith(JOBS_PREFIX) && Date.now() - fs10.statSync(left).mtimeMs > 36e5) {
+        fs10.rmSync(left, { recursive: true, force: true });
+      }
+    }
+    root = fs10.realpathSync(fs10.mkdtempSync(path10.join(os2.tmpdir(), JOBS_PREFIX)));
+  } catch {
+    return results;
+  }
+  const queue = [...gates];
+  const line = async (dir) => {
+    for (let gate = queue.shift(); gate !== void 0; gate = queue.shift()) {
+      const spec = gate.spec;
+      results.set(
+        gate,
+        await new Promise((resolve) => {
+          const child = spawn(executable, [...args, ...jobFlags(runner, dir)], {
+            cwd: manifest.dir,
+            env: { ...process.env, [EXCLUDE_ENV]: spec, [EXCLUDE_ALL_ENV]: "", [TOUCH_ENV]: "" },
+            shell: process.platform === "win32"
+          });
+          let stdout = "";
+          let stderr = "";
+          child.stdout.on("data", (chunk) => stdout += chunk.toString());
+          child.stderr.on("data", (chunk) => stderr += chunk.toString());
+          child.stdin.on("error", () => void 0);
+          child.stdin.end();
+          child.on("error", () => resolve({ status: null, signal: null, stdout, stderr }));
+          child.on("close", (status, signal) => resolve({ status, signal, stdout, stderr }));
+        })
+      );
+    }
+  };
+  try {
+    await Promise.all(
+      Array.from(
+        { length: Math.min(jobs, gates.length) },
+        (_unused, index) => line(path10.join(root, `line-${index}`))
+      )
+    );
+  } finally {
+    fs10.rmSync(root, { recursive: true, force: true });
+  }
+  return results;
+}
+async function runSelfcheck(dir, selection, commandOverride, io2) {
+  const refused = selection.quick === true ? quickRefused(process.env) : null;
+  if (refused !== null) {
+    throw new UsageError(refused);
+  }
   const manifest = readManifest(dir);
   if (manifest.violations.length > 0 || manifest.gates.length === 0) {
     io2.err('test-gates selfcheck: test-gates.json has problems. Run "test-gates check" first');
     return 1;
   }
+  const chosen = selectControls({
+    gates: manifest.gates.map((gate) => gate.path),
+    mode: selection.mode ?? manifest.settings.selfcheckMode,
+    only: selection.gates,
+    shard: selection.shard
+  });
+  if ("error" in chosen) {
+    throw new UsageError(chosen.error);
+  }
+  const targets = manifest.gates.filter((gate) => chosen.selected.includes(gate.path));
+  const skipped = manifest.gates.length - targets.length;
+  const notSelected = selection.shard !== null ? `, ${skipped} gate(s) not selected by --shard ${selection.shard.index}/${selection.shard.total}` : selection.gates.length > 0 ? `, ${skipped} gate(s) not selected by --gate` : "";
   const command = commandOverride.length > 0 ? commandOverride : resolveGateCommand(manifest);
   const [program, ...args] = command;
   const executable = findLocalBin(manifest.dir, program) ?? program;
-  const targets = (mode ?? manifest.settings.selfcheckMode) === "first" ? manifest.gates.slice(0, 1) : manifest.gates;
+  const runGate = (env) => spawnSync3(executable, args, {
+    cwd: manifest.dir,
+    env: {
+      ...process.env,
+      [EXCLUDE_ENV]: env.exclude ?? "",
+      [EXCLUDE_ALL_ENV]: env.excludeAll === void 0 ? "" : JSON.stringify(env.excludeAll),
+      [TOUCH_ENV]: env.touchDir ?? ""
+    },
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024,
+    shell: process.platform === "win32"
+  });
+  const judge = (result, gatePath) => result.error ? `cannot start "${command.join(" ")}" (${result.error.message})` : judgeSelfcheck({
+    status: result.status,
+    output: `${result.stdout ?? ""}${result.stderr ?? ""}`,
+    gatePath,
+    failurePattern: manifest.settings.selfcheckFailurePattern
+  });
+  const heldTogether = /* @__PURE__ */ new Map();
+  const single = targets.filter((gate) => gate.spec !== null && gate.existingSpecs.length === 1);
+  if (selection.quick === true && single.length >= 3) {
+    const configSource = gateConfigSource(manifest, args);
+    const shared = sharedRunPrecheck({
+      program,
+      version: installedVersion2(manifest.dir, program),
+      configSource,
+      specs: manifest.gates.flatMap(
+        (gate) => gate.existingSpecs.map((spec) => ({ path: spec, source: readText(manifest.dir, spec) }))
+      )
+    }) ?? shareOneRun(manifest, single, runGate);
+    if (typeof shared === "string" || "reason" in shared) {
+      const reason = typeof shared === "string" ? shared : shared.reason;
+      io2.out(`test-gates selfcheck: a run of the gate command for every gate (${reason})`);
+    } else {
+      for (const gate of shared.gates) {
+        if (judge(shared.result, gate.path) === null) {
+          heldTogether.set(gate.path, shared.result.status);
+        }
+      }
+    }
+  }
+  const heldAtOnce = /* @__PURE__ */ new Map();
+  const waiting = single.filter((gate) => !heldTogether.has(gate.path));
+  const jobs = selection.jobs ?? 1;
+  if (jobs > 1 && waiting.length > 1) {
+    const known = knownCommand(program, args);
+    const configFile = gateConfigFile(args);
+    const ask = (loaded) => jobsRefused({
+      failurePattern: manifest.settings.selfcheckFailurePattern,
+      command: known,
+      configSource: gateConfigSource(manifest, args),
+      ...loaded,
+      trusted: manifest.settings.importMode === "allowlist" ? manifest.settings.importAllow.flatMap(
+        (rule) => rule.module === void 0 ? [] : [rule.module]
+      ) : []
+    });
+    const refusal = ask({ files: [], lost: null }) ?? ask(loadedFiles(manifest, configFile));
+    if (refusal !== null || !("runner" in known)) {
+      io2.out(`test-gates selfcheck: one negative control at a time (${refusal})`);
+    } else {
+      const specs = new Set(manifest.gates.map((gate) => gate.spec)).size - 1;
+      const names = [
+        manifest.dir,
+        realPath(manifest.dir),
+        ...manifest.gates.flatMap((gate) => [gate.path, gate.spec])
+      ].sort((left, right) => right.length - left.length);
+      const results = await runAtOnce(manifest, waiting, jobs, known.runner, executable, args);
+      for (const [gate, result] of results) {
+        const output = `${result.stdout}${result.stderr}`;
+        const clean = cleanHold({
+          held: judgeSelfcheck({ status: result.status, output, gatePath: gate.path }) === null,
+          signal: result.signal,
+          output,
+          runner: known.runner,
+          specs,
+          gatePath: gate.path,
+          others: manifest.gates.map((other) => other.path).filter((other) => other !== gate.path),
+          names
+        });
+        if (clean) {
+          heldAtOnce.set(gate.path, result.status);
+        }
+      }
+      const again = waiting.length - heldAtOnce.size;
+      if (again > 0) {
+        io2.out(
+          `test-gates selfcheck: ${again} of ${waiting.length} negative control(s) did not hold cleanly next to others and run again on their own`
+        );
+      }
+    }
+  }
   let failed = 0;
   for (const gate of targets) {
     if (gate.spec === null || gate.existingSpecs.length !== 1) {
@@ -1725,20 +3150,19 @@ function runSelfcheck(dir, mode, commandOverride, io2) {
       failed += 1;
       continue;
     }
-    const result = spawnSync2(executable, args, {
-      cwd: manifest.dir,
-      env: { ...process.env, [EXCLUDE_ENV]: gate.spec },
-      encoding: "utf8",
-      maxBuffer: 256 * 1024 * 1024,
-      shell: process.platform === "win32"
-    });
+    if (heldTogether.has(gate.path)) {
+      io2.out(
+        `  \u2713 without ${gate.spec} the gate fails (exit ${heldTogether.get(gate.path)}, in the shared run)`
+      );
+      continue;
+    }
+    if (heldAtOnce.has(gate.path)) {
+      io2.out(`  \u2713 without ${gate.spec} the gate fails (exit ${heldAtOnce.get(gate.path)})`);
+      continue;
+    }
+    const result = runGate({ exclude: gate.spec });
     const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const reason = result.error ? `cannot start "${command.join(" ")}" (${result.error.message})` : judgeSelfcheck({
-      status: result.status,
-      output,
-      gatePath: gate.path,
-      failurePattern: manifest.settings.selfcheckFailurePattern
-    });
+    const reason = judge(result, gate.path);
     if (reason === null) {
       io2.out(`  \u2713 without ${gate.spec} the gate fails (exit ${result.status})`);
     } else {
@@ -1763,10 +3187,14 @@ function runSelfcheck(dir, mode, commandOverride, io2) {
     }
   }
   if (failed > 0) {
-    io2.err(`test-gates selfcheck: FAILED (${failed} of ${targets.length} negative control(s))`);
+    io2.err(
+      `test-gates selfcheck: FAILED (${failed} of ${targets.length} negative control(s)${notSelected})${quickCaveat(heldTogether.size)}`
+    );
     return 1;
   }
-  io2.out(`test-gates selfcheck: OK (${targets.length} negative control(s) failed as they should)`);
+  io2.out(
+    `test-gates selfcheck: OK (${targets.length} negative control(s) failed as they should${notSelected})${quickCaveat(heldTogether.size)}`
+  );
   return 0;
 }
 
@@ -1781,12 +3209,21 @@ Commands:
                               Unknown arguments and everything after "--" go to Stryker
   mutation-result             Judge an existing Stryker JSON report
   selfcheck [-- <command>]    Negative control: leave one spec out, the gate must fail
-  lcov --file <lcov.info>     Per-file 100% line coverage from an lcov tracefile
+  lcov [--file <lcov.info>]   Per-file 100% line coverage from an lcov tracefile
 
 Options:
   --dir <subproject>          Directory that holds test-gates.json (default: .)
   --report <path>             mutation-result: report to judge (default: settings.stryker.reportFile)
   --all | --first             selfcheck: every gate in turn (default) or only the first
+  --gate <path>               selfcheck: only this gate (may be given more than once).
+                              mutation: only the mutants of this gate, while working on it.
+                              Not the final check, and refused when CI is set
+  --shard <index>/<total>     selfcheck: one of <total> parts of the gates, for parallel CI jobs
+  --jobs <n>                  selfcheck: run <n> negative controls at the same time. One that does
+                              not hold cleanly there is run again on its own
+  --quick                     selfcheck: one run for the gates only their own spec touches.
+                              Not the final check: it assumes that no spec depends on which
+                              other specs run. Refused when CI is set
   --file <path>               lcov: tracefile (default: settings.lcov.file)
   -h, --help                  Show this help
   -v, --version               Show the version
@@ -1802,7 +3239,7 @@ var io = {
 function main(argv) {
   const args = parseArgs(argv);
   if (args.version) {
-    const { version } = createRequire(import.meta.url)("../package.json");
+    const { version } = createRequire2(import.meta.url)("../package.json");
     io.out(version);
     return 0;
   }
@@ -1814,11 +3251,22 @@ function main(argv) {
     case "check":
       return runCheck(args.dir, io);
     case "mutation":
-      return runMutation(args.dir, args.rest, io);
+      return runMutation(args.dir, args.rest, io, args.gates);
     case "mutation-result":
       return runMutationResult(args.dir, args.report, io);
     case "selfcheck":
-      return runSelfcheck(args.dir, args.mode, args.rest, io);
+      return runSelfcheck(
+        args.dir,
+        {
+          mode: args.mode,
+          gates: args.gates,
+          shard: args.shard,
+          quick: args.quick,
+          jobs: args.jobs
+        },
+        args.rest,
+        io
+      );
     case "lcov":
       return runLcov(args.dir, args.file, io);
     case null:
@@ -1826,7 +3274,7 @@ function main(argv) {
   }
 }
 try {
-  process.exitCode = main(process.argv.slice(2));
+  process.exitCode = await main(process.argv.slice(2));
 } catch (error) {
   if (error instanceof UsageError) {
     io.err(`test-gates: ${error.message}